LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::popBlock()
void CppFuncBase::popBlock()
{
	
	{
		if (blockLevel<=0)
		{
			throw PhplusError("CppProgram::popBlock called with zero indentationLevel", INTERNAL_ERROR);
		}
		
		blockLevel--;
		namespaceStack.pop_back();
		code("}\n");
		freshLine=true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x19190
movq %rdi, %rbx
decl %eax
movl %eax, 0x24(%rdi)
movq 0xa0(%rdi), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0xa0(%rdi)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0x19149
callq 0xdce4
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5eeb3(%rip), %rsi     # 0x7800c
leaq 0x5eeae(%rip), %rdx     # 0x7800e
movq %rsp, %rdi
callq 0xdfa8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1861a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19181
callq 0xa2b0
movb $0x1, 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5e97d(%rip), %rsi     # 0x77b2a
leaq 0x5e9ac(%rip), %rdx     # 0x77b60
leaq 0x38(%rsp), %rdi
callq 0xdfa8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x7e451(%rip), %rsi     # 0x97638
leaq -0x46c8(%rip), %rdx     # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19208
callq 0xdce4
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x19217
callq 0xa2b0
testb %bpl, %bpl
jne 0x19221
jmp 0x19241
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
jmp 0x19241
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19241
callq 0xa2b0
jmp 0x19241
movq %rax, %r14
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/CppProgram.cpp
// Function: CppProgram::declareGlobal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<TypeBase>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void CppProgram::declareGlobal(const string& nameIn, Type typeIn, string initialValue)
{
	if (globalNames->hasPp(nameIn))
		return;
	
	string code;
	code+=getTypeCode(typeIn);
	code+=" ";
	globalNames->addPp(nameIn);
	code+=globalNames->getCpp(nameIn);
	if (!initialValue.empty())
	{
		code+=" = ";
		code+=initialValue;
	}
	code+=";\n";
	
	globalVarCode+=code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0xf8(%rdi), %r13
leaq 0x38(%r13), %rdi
movq %r15, %rsi
callq 0x1ec04
leaq 0x40(%r13), %rcx
cmpq %rcx, %rax
jne 0x1ca4e
movq 0x68(%r13), %r13
testq %r13, %r13
jne 0x1c8b9
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq (%r12), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x1c91e
movq 0x7d698(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x1c91a
incl 0x8(%rax)
jmp 0x1c91e
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x1aab2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa110
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x1c957
callq 0xa2b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1c966
callq 0xdce4
leaq 0x5b12f(%rip), %rsi     # 0x77a9c
leaq 0x28(%rsp), %rdi
callq 0xa560
movq 0xf8(%rbx), %r12
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x5afb8(%rip), %rsi     # 0x77945
leaq 0x5afd6(%rip), %rdx     # 0x7796a
callq 0xdfa8
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x17b94
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c9b8
callq 0xa2b0
movq 0xf8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x18386
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa110
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c9ef
callq 0xa2b0
cmpq $0x0, 0x8(%r14)
je 0x1ca18
leaq 0x5df3e(%rip), %rsi     # 0x7a93b
leaq 0x28(%rsp), %rdi
callq 0xa560
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa110
leaq 0x5dc9d(%rip), %rsi     # 0x7a6bc
leaq 0x28(%rsp), %rdi
callq 0xa560
addq $0x60, %rbx
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0xa110
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ca4e
callq 0xa2b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ca61
jmp 0x1caa3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1caa6
callq 0xa2b0
jmp 0x1caa6
jmp 0x1caa3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ca92
callq 0xa2b0
jmp 0x1ca92
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1caa6
callq 0xdce4
jmp 0x1caa6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cab5
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/ErrorHandler.cpp
// Function: ErrorHandler::priorityToStr[abi:cxx11](ErrorPriority)
string ErrorHandler::priorityToStr(ErrorPriority in)
{
	switch (in)
	{
	case SOURCE_ERROR:
		return "error";
		break;
		
	case SOURCE_WARNING:
		return "warning";
		break;
		
	case JSYK:
		return "jsyk";
		break;
		
	case INTERNAL_ERROR:
		return "INTERNAL ERROR";
		break;
		
	case RUNTIME_ERROR:
		return "runtime error";
		break;
		
	default:
		return "UNKNOWN PRIORITY LEVEL";
		break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x4, %esi
ja 0x1fc2a
movl %esi, %eax
leaq 0x584c7(%rip), %rcx     # 0x78098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x584ef(%rip), %rsi     # 0x780d0
leaq 0x584ed(%rip), %rdx     # 0x780d5
jmp 0x1fc38
leaq 0x584d7(%rip), %rsi     # 0x780c8
leaq 0x584dd(%rip), %rdx     # 0x780d5
jmp 0x1fc38
leaq 0x584b3(%rip), %rsi     # 0x780b4
leaq 0x584b0(%rip), %rdx     # 0x780b8
jmp 0x1fc38
leaq 0x584a8(%rip), %rsi     # 0x780b9
leaq 0x584af(%rip), %rdx     # 0x780c7
jmp 0x1fc38
leaq 0x5848b(%rip), %rsi     # 0x780ac
leaq 0x5848b(%rip), %rdx     # 0x780b3
jmp 0x1fc38
leaq 0x584a5(%rip), %rsi     # 0x780d6
leaq 0x584b4(%rip), %rdx     # 0x780ec
movq %rbx, %rdi
callq 0xdfa8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Lexer.cpp
// Function: CharClassifier::setUp()
void CharClassifier::setUp()
{
	hm[' ']=WHITESPACE;
	hm['\t']=WHITESPACE;
	
	hm['\n']=NEWLINE;
	hm[';']=LINE_BREAK;
	
	for (char c='a'; c<='z'; ++c)
		hm[c]=LETTER;
	
	for (char c='A'; c<='Z'; ++c)
		hm[c]=LETTER;
	
	hm['_']=LETTER;
	
	for (char c='0'; c<='9'; ++c)
		hm[c]=DIGIT;
	
	hm['#']=SINGLE_LINE_COMMENT;
	
	hm['"']=STRING_QUOTE;
	
	unordered_map<string, Operator>& opsMap=ops->getOpsMap();
	
	for (auto i=opsMap.begin(); i!=opsMap.end(); ++i)
	{
		string str=(*i).first;
		for (unsigned j=0; j<str.size(); j++)
		{
			hm[str[j]]=OPERATOR;
		}
	}
	
	hasSetUp=true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movb $0x20, (%r14)
movq %r14, %rsi
callq 0x21594
xorl %ebp, %ebp
movl %ebp, (%rax)
movb $0x9, (%r14)
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21594
movl %ebp, (%rax)
movb $0xa, (%r15)
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21594
movl $0x2, (%rax)
movb $0x3b, (%r15)
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21594
movl $0x1, (%rax)
movb $0x61, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21822
movl $0x3, (%rax)
movb (%rsp), %al
incb %al
movb %al, (%rsp)
cmpb $0x7b, %al
jl 0x20596
movq %rsp, %r14
movb $0x41, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21822
movl $0x3, (%rax)
movb (%rsp), %al
incb %al
movb %al, (%rsp)
cmpb $0x5b, %al
jl 0x205ba
movq %rsp, %r14
movb $0x5f, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21594
movl $0x3, (%rax)
movb $0x30, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21822
movl $0x4, (%rax)
movb (%rsp), %al
incb %al
movb %al, (%rsp)
cmpb $0x3a, %al
jl 0x205f3
movq %rsp, %r14
movb $0x23, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21594
movl $0x7, (%rax)
movb $0x22, (%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21594
movl $0x6, (%rax)
leaq 0x79cc4(%rip), %rax     # 0x9a308
movq (%rax), %rax
movq 0x200(%rax), %r12
testq %r12, %r12
je 0x206b7
leaq 0x10(%rsp), %r15
movq %rsp, %r14
movq %r15, (%rsp)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xde0c
cmpq $0x0, 0x8(%rsp)
je 0x206a0
movl $0x1, %ebp
xorl %esi, %esi
addq (%rsp), %rsi
movq %rbx, %rdi
callq 0x21822
movl $0x5, (%rax)
movl %ebp, %esi
incl %ebp
cmpq %rsi, 0x8(%rsp)
ja 0x20683
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x206ae
callq 0xa2b0
movq (%r12), %r12
testq %r12, %r12
jne 0x2065b
movb $0x1, 0x38(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x206d9
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Lexer.cpp
// Function: CharClassifier::getTokenType(CharClassifier::Type, TokenData::Type)
inline TokenData::Type CharClassifier::getTokenType(CharClassifier::Type type, TokenData::Type previousType)
{
	if (previousType==TokenData::LINE_COMMENT)
	{
		if (type==NEWLINE)
			return TokenData::WHITESPACE;
		else
			return TokenData::LINE_COMMENT;
	}
	else if (previousType==TokenData::BLOCK_COMMENT)
	{
		if (type==MULTI_LINE_COMMENT_END)
			return TokenData::WHITESPACE;
		else
			return TokenData::BLOCK_COMMENT;
	}
	else if (previousType==TokenData::STRING_LITERAL)
	{
		if (type==STRING_QUOTE)
			return TokenData::WHITESPACE;
		else
			return TokenData::STRING_LITERAL;
		
	}
	
	switch (type)
	{
	
	case SINGLE_LINE_COMMENT:
		return TokenData::LINE_COMMENT;
	
	case MULTI_LINE_COMMENT_START:
		return TokenData::BLOCK_COMMENT;
	
	case MULTI_LINE_COMMENT_END:
		error.log("block comment end without start", SOURCE_ERROR);
		return TokenData::UNKNOWN;
		
	case WHITESPACE:
		return TokenData::WHITESPACE;
		
	case LINE_BREAK:
	case NEWLINE:
		return TokenData::LINE_END;
		
	case OPERATOR:
		return TokenData::OPERATOR;
		
	case LETTER:
	case DIGIT:
		if (previousType==TokenData::IDENTIFIER || previousType==TokenData::LITERAL)
			return previousType;
		else if (type==DIGIT)
			return TokenData::LITERAL;
		else
			return TokenData::IDENTIFIER;
		
	case STRING_QUOTE:
		return TokenData::STRING_LITERAL;
		
	default:
		return TokenData::UNKNOWN;
		
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x4, %esi
je 0x21279
movl %esi, %ebx
cmpl $0x7, %esi
je 0x2126a
cmpl $0x6, %ebx
jne 0x2128e
xorl %eax, %eax
cmpl $0x2, %edi
movl $0x6, %ebx
jmp 0x21274
xorl %eax, %eax
cmpl $0x9, %edi
movl $0x7, %ebx
cmovel %eax, %ebx
jmp 0x21284
xorl %ebx, %ebx
cmpl $0x6, %edi
setne %bl
shll $0x2, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
cmpl $0x9, %edi
ja 0x21349
movl %edi, %eax
leaq 0x56e70(%rip), %rcx     # 0x78110
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %edi, %ebx
jmp 0x21284
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
je 0x21284
xorl %ebx, %ebx
cmpl $0x4, %edi
sete %bl
orl $0x2, %ebx
jmp 0x21284
movl $0x1, %ebx
jmp 0x21284
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x56e79(%rip), %rsi     # 0x78154
leaq 0x56e91(%rip), %rdx     # 0x78173
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xdfa8
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x79014(%rip), %rdi     # 0x9a313
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1fc46
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21318
callq 0xdce4
movq 0x18(%rsp), %rdi
movl $0xb, %ebx
cmpq %r14, %rdi
je 0x21284
callq 0xa2b0
jmp 0x21284
movl $0x6, %ebx
jmp 0x21284
movl $0x4, %ebx
jmp 0x21284
movl $0xb, %ebx
jmp 0x21284
movl $0x7, %ebx
jmp 0x21284
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2136f
callq 0xdce4
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2137e
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::IdMap::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>)
void NamespaceData::IdMap::add(string key, AstNode node)
{
	auto i=nodes.find(key);
	
	if (i==nodes.end())
	{
		nodes[key]=vector<AstNode>();
	}
	
	nodes[key].push_back(move(node));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x262f2
testq %rax, %rax
jne 0x21c0a
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x263ee
movq 0x10(%rax), %rcx
movups (%rax), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq %rcx, 0x10(%rdi)
movq %rsp, %r12
movaps %xmm1, (%r12)
movq %rdx, 0x10(%r12)
callq 0x25f22
movq %r12, %rdi
callq 0x25f22
movq %r15, %rdi
movq %r14, %rsi
callq 0x263ee
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16d06
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x25f22
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::IdMap::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<AstNodeBase*, std::allocator<AstNodeBase*>>&)
void NamespaceData::IdMap::get(string key, vector<AstNodeBase*>& out)
{
	auto matches=nodes.find(key);
	
	if (matches!=nodes.end())
	{
		for (unsigned i=0; i<matches->second.size(); i++)
		{
			out.push_back(&*matches->second[i]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x262f2
testq %rax, %rax
je 0x21caa
movq %rax, %r14
movq 0x28(%rax), %rax
cmpq %rax, 0x30(%r14)
je 0x21caa
movl $0x1, %ebp
xorl %ecx, %ecx
movq %rsp, %r15
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x21c87
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x21c92
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2671e
movl %ebp, %ecx
movq 0x28(%r14), %rax
movq 0x30(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x21c6b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::getCopier(std::shared_ptr<TypeBase>)
Action NamespaceData::getCopier(Type type)
{
	return getActionForTokenWithInput(makeToken("__copy__"), Void, type, false, false, nullptr);
	
	/*
	vector<AstNodeBase*> nodes;
	
	copiers.get(str::ptrToUniqueStr(&*type, 6), nodes);
	
	if (nodes.empty())
	{
		if (parent)
			return parent->getCopier(type);
		else
			return nullptr;
	}
	else if (nodes.size()>1)
	{
		throw PhplusError("multiple copiers for a single type in a single namespace", INTERNAL_ERROR);
	}
	else
	{
		return nodes[0]->getAction();
	}
	*/
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x54274(%rip), %rsi     # 0x782a4
leaq 0x54275(%rip), %rdx     # 0x782ac
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0xdfa8
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x53eb2
leaq 0x763a8(%rip), %rax     # 0x9a400
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x24083
movq 0x75f33(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x2407f
incl 0x8(%rax)
jmp 0x24083
lock
incl 0x8(%rax)
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x240ad
movq 0x75f09(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x240a9
incl 0x8(%rax)
jmp 0x240ad
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x247ec
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x240e9
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x240f8
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x24107
callq 0xdce4
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x24116
callq 0xa2b0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24139
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x24148
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2415c
callq 0xdce4
jmp 0x2415c
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x2416b
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::getDestroyer(std::shared_ptr<TypeBase>)
Action NamespaceData::getDestroyer(Type type)
{
	return getActionForTokenWithInput(makeToken("__destroy__"), Void, type, false, false, nullptr);
	
	/*
	vector<AstNodeBase*> nodes;
	
	destructors.get(str::ptrToUniqueStr(&*type, 6), nodes);
	
	if (nodes.empty())
	{
		if (parent)
			return parent->getDestroyer(type);
		else
			return nullptr;
	}
	else if (nodes.size()>1)
	{
		throw PhplusError("multiple destroyers for a single type in a single namespace", INTERNAL_ERROR);
	}
	else
	{
		return nodes[0]->getAction();
	}
	*/
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x540fe(%rip), %rsi     # 0x78298
leaq 0x54102(%rip), %rdx     # 0x782a3
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0xdfa8
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x53eb2
leaq 0x7623e(%rip), %rax     # 0x9a400
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x241ed
movq 0x75dc9(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x241e9
incl 0x8(%rax)
jmp 0x241ed
lock
incl 0x8(%rax)
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x24217
movq 0x75d9f(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x24213
incl 0x8(%rax)
jmp 0x24217
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x247ec
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24253
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x24262
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x24271
callq 0xdce4
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x24280
callq 0xa2b0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x242a3
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x242b2
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x242c6
callq 0xdce4
jmp 0x242c6
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x242d5
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::getNodes(std::vector<AstNodeBase*, std::allocator<AstNodeBase*>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool, bool)
void NamespaceData::getNodes(vector<AstNodeBase*>& out, string text, bool checkActions, bool checkDynamic, bool checkWhatev)
{
	if (checkActions)
	{
		actions.get(text, out);
	}
	
	if (checkDynamic)
	{
		dynamicActions.get(text, out);
	}
	
	if (checkWhatev)
	{
		whatevActions.get(text, out);
	}
	
	if (parent)
		parent->getNodes(out, text, checkActions, checkDynamic, checkWhatev);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, (%rsp)
movl %r8d, 0x4(%rsp)
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
testl %ecx, %ecx
je 0x25c70
leaq 0x50(%r13), %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
callq 0xde0c
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x21c40
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x25c70
callq 0xa2b0
cmpb $0x0, 0x4(%rsp)
je 0x25cc2
leaq 0x88(%r13), %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0xde0c
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x21c40
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x25cc2
callq 0xa2b0
cmpb $0x0, (%rsp)
je 0x25d13
leaq 0xc0(%r13), %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0xde0c
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x21c40
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x25d13
callq 0xa2b0
movq 0x30(%r13), %r13
testq %r13, %r13
je 0x25d6a
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0xde0c
movzbl %r15b, %ecx
movzbl 0x4(%rsp), %r8d
movzbl (%rsp), %r9d
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25bfe
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x25d6a
callq 0xa2b0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
jmp 0x25da7
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
jmp 0x25da7
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x25db1
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x25dac
jmp 0x25db1
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::nodesToMatchingActions(std::vector<std::shared_ptr<ActionData>, std::allocator<std::shared_ptr<ActionData>>>&, std::vector<AstNodeBase*, std::allocator<AstNodeBase*>>&, std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
void NamespaceData::nodesToMatchingActions(vector<Action>& out, vector<AstNodeBase*>& nodes, Type leftInType, Type rightInType)
{
	for (auto i: nodes)
	{
		Action action=i->getAction();
		
		if (action->getInLeftType()->matches(leftInType) && action->getInRightType()->matches(rightInType))
			out.push_back(action);
		
		//Action converter=getConverter(action, leftInType, rightInType);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq (%rdx), %r13
movq 0x8(%rdx), %r15
cmpq %r15, %r13
je 0x25ed1
movq %r8, %rbx
movq %rcx, %r14
leaq 0x20(%rsp), %r12
movq (%r13), %rsi
movq %r12, %rdi
callq 0x14dfa
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x25e36
movq 0x74180(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x25e32
incl 0x8(%rax)
jmp 0x25e36
lock
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
callq 0x55538
testb %al, %al
je 0x25e73
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rbx), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x25e7b
movq 0x7413f(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x25e77
incl 0x8(%rax)
jmp 0x25e7b
xorl %ebp, %ebp
jmp 0x25e94
lock
incl 0x8(%rax)
movq %rsp, %rsi
callq 0x55538
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25e94
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25ea3
callq 0xdce4
testb %bpl, %bpl
je 0x25eb5
movq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x14f30
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x25ec4
callq 0xdce4
addq $0x8, %r13
cmpq %r15, %r13
jne 0x25df6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25efc
callq 0xdce4
jmp 0x25efc
movq %rax, %rbx
jmp 0x25f0b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25f0b
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x25f1a
callq 0xdce4
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstActionWrapper::make(std::shared_ptr<ActionData>)
static unique_ptr<AstActionWrapper> make(Action actionIn) {
		auto out = unique_ptr<AstActionWrapper>(new AstActionWrapper);
		out->inLeftType=actionIn->getInLeftType();
		out->inRightType=actionIn->getInRightType();
		out->returnType=actionIn->getReturnType();
		out->action=actionIn;
		out->dynamic=true; // shouldn't matter
		out->ns=nullptr; // shouldn't matter
		out->inputHasBeenSet=true;
		return out;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0xa2d0
movq %rax, %r14
addq $0x18, %rax
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
xorl %eax, %eax
movb %al, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movb %al, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %al, 0x80(%r14)
leaq 0x71cfc(%rip), %rax     # 0x97d00
movq %rax, (%r14)
movq %r14, (%rbx)
movq (%r15), %rsi
movq 0x38(%rsi), %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %rdi
addq $0x40, %rsi
callq 0xdea2
movq (%r15), %rsi
movq 0x48(%rsi), %rax
movq %rax, 0x38(%r14)
leaq 0x40(%r14), %rdi
addq $0x50, %rsi
callq 0xdea2
movq (%r15), %rsi
movq 0x28(%rsi), %rax
movq %rax, 0x58(%r14)
leaq 0x60(%r14), %rdi
addq $0x30, %rsi
callq 0xdea2
movq (%r15), %rax
movq %rax, 0x48(%r14)
leaq 0x50(%r14), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xdea2
movb $0x1, 0x68(%r14)
movq 0x78(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
testq %rdi, %rdi
je 0x26084
callq 0xdce4
movb $0x1, 0x80(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/Parser.cpp
// Function: astNodeFromTokens(std::vector<std::shared_ptr<TokenData>, std::allocator<std::shared_ptr<TokenData>>> const&, int, int)
AstNode astNodeFromTokens(const vector<Token>& tokens, int left, int right)
{
	vector<AstNode> nodes;
	
	parseTokenList(tokens, left, right, nodes);
	
	if (nodes.size()==0)
	{
		return AstVoid::make();
	}
	else if (nodes.size()==1)
	{
		return move(nodes[0]);
	}
	else
	{
		return AstList::make(nodes);
	}
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rsi, %rdi
movl %edx, %esi
movl %ecx, %edx
movq %rax, %rcx
callq 0x26c79
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x26c2d
testq %rcx, %rcx
jne 0x26c3c
movl $0x88, %edi
callq 0xa2d0
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movb %cl, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movb %cl, 0x68(%rax)
movups %xmm0, 0x70(%rax)
movb %cl, 0x80(%rax)
leaq 0x71200(%rip), %rcx     # 0x97e28
movq %rcx, (%rax)
jmp 0x26c4e
movq (%rax), %rcx
movq %rcx, (%rbx)
movq $0x0, (%rax)
jmp 0x26c51
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x2b868
movq 0x18(%rsp), %rax
movq %rax, (%rbx)
movq %rsp, %rdi
callq 0x25f22
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x26c66
jmp 0x26c66
movq %rax, %rbx
movq %rsp, %rdi
callq 0x25f22
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstOpWithInput::make(std::vector<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::allocator<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>>>&, std::shared_ptr<TokenData>, std::vector<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::allocator<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>>>&)
static unique_ptr<AstOpWithInput> make(vector<AstNode>& leftInIn, Token tokenIn, vector<AstNode>& rightInIn)
	{
		unique_ptr<AstOpWithInput> node(new AstOpWithInput);
		
		node->leftIn=move(leftInIn);
		node->token=tokenIn;
		node->rightIn=move(rightInIn);
		
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %rdi, 0x8(%rsp)
movl $0xc8, %edi
callq 0xa2d0
movq %rax, %r15
addq $0x18, %rax
movq %rax, 0x8(%r15)
xorl %ebx, %ebx
movq %rbx, 0x10(%r15)
movb %bl, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
movb %bl, 0x68(%r15)
movups %xmm0, 0x70(%r15)
movb %bl, 0x80(%r15)
leaq 0x6bed6(%rip), %rax     # 0x978f0
addq $0x10, %rax
movq %rax, (%r15)
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movups %xmm0, 0xa8(%r15)
movups %xmm0, 0xb8(%r15)
movq %r15, (%rbp)
movups (%r13), %xmm0
movups %xmm0, 0x98(%r15)
movq 0x10(%r13), %rax
movq %rax, 0xa8(%r15)
leaq 0x10(%rsp), %rbp
movq %rbx, 0x10(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbp)
movq %rbx, 0x10(%r13)
movups %xmm0, (%r13)
movq %rbp, %rdi
callq 0x25f22
movq (%r12), %rax
movq %rax, 0x88(%r15)
leaq 0x90(%r15), %rdi
addq $0x8, %r12
movq %r12, %rsi
callq 0xdea2
movq 0xc0(%r15), %rax
movups (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0xc0(%r15)
movups 0xb0(%r15), %xmm1
movups %xmm0, 0xb0(%r15)
movaps %xmm1, (%rbp)
movq %rax, 0x10(%rbp)
movq %rbx, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x10(%rsp), %rdi
callq 0x25f22
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstConstExpression::make(std::unique_ptr<AstToken, std::default_delete<AstToken>>, std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>)
static unique_ptr<AstConstExpression> make(unique_ptr<AstToken> centerIn, AstNode rightInIn)
	{
		unique_ptr<AstConstExpression> node(new AstConstExpression);
		
		//node->leftIn=move(leftInIn);
		node->center=move(centerIn);
		node->rightIn=move(rightInIn);
		
		return node;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x98, %edi
callq 0xa2d0
movq %rax, %r14
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %r13d, %r13d
movq %r13, 0x10(%r14)
movb %r13b, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movb %r13b, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %r13b, 0x80(%r14)
leaq 0x6bc82(%rip), %rax     # 0x97868
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x88(%r14), %rdi
movups %xmm0, 0x88(%r14)
movq %r14, (%rbx)
movq (%r12), %rsi
movq %r13, (%r12)
callq 0x16e7c
movq (%r15), %rax
movq %r13, (%r15)
movq 0x90(%r14), %rsi
movq %rax, 0x90(%r14)
testq %rsi, %rsi
je 0x2bc34
addq $0x90, %r14
movq %r14, %rdi
callq 0x16b80
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusProgram.cpp
// Function: PhplusProgram::getCpp[abi:cxx11]()
string PhplusProgram::getCpp()
{
	try
	{
		CppProgram outProg;
		actionRoot->addToProg(voidAction, voidAction, &outProg);
		return outProg.getCppCode();
	}
 	catch (PhplusError err)
	{
		err.log();
		return "/* no program due to transpiling error */";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19264
movq 0x30(%r14), %rdi
leaq 0x6d295(%rip), %rdx     # 0x9a370
movq (%rdx), %rsi
movq 0x8(%rdx), %rax
movq %rsi, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x2d10c
movq 0x6ceb0(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x2d11c
incl 0x8(%rax)
movq %rsi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x2d136
movq %rsi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x2d144
lock
incl 0x8(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rax
movq %rsi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2d144
cmpb $0x0, (%rcx)
je 0x2d140
incl 0x8(%rax)
jmp 0x2d144
lock
incl 0x8(%rax)
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq *0x28(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2d168
callq 0xdce4
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2d177
callq 0xdce4
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1db5c
leaq 0x28(%rsp), %rdi
callq 0x2d39c
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x2d1ca
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2d1bb
callq 0xdce4
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2d1ca
callq 0xdce4
leaq 0x28(%rsp), %rdi
callq 0x2d39c
jmp 0x2d1dc
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x2d24e
movq %r14, %rdi
callq 0xa380
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x14f76
movq %r14, %rdi
callq 0xa170
leaq 0x28(%rsp), %rdi
callq 0x20470
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b5d0(%rip), %rsi     # 0x787e7
leaq 0x4b5f2(%rip), %rdx     # 0x78810
movq %rbx, %rdi
callq 0xdfa8
leaq 0x28(%rsp), %rdi
callq 0x14b26
callq 0xa4c0
jmp 0x2d18e
jmp 0x2d23c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x14b26
callq 0xa4c0
movq %r14, %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcd8
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusProgram.cpp
// Function: PhplusProgram::execute()
void PhplusProgram::execute()
{
	try
	{
		stackPtr=globalFramePtr=malloc(globalNamespace->getStackFrame()->getSize());
		free(actionRoot->execute(nullptr, nullptr));
		free(globalFramePtr);
		stackPtr=globalFramePtr=nullptr;
	}
	catch (PhplusError err)
	{
		err.log();
		cout << endl << ">>>>>>    program aborted due to error    <<<<<<" << endl;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x6d111(%rip), %rax     # 0x9a380
movq (%rax), %rcx
movq 0x40(%rcx), %rax
movq 0x48(%rcx), %r14
testq %r14, %r14
je 0x2d291
movq 0x6cd22(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x2d2b0
incl 0x8(%r14)
jmp 0x2d2b5
movq 0x18(%rax), %rdi
callq 0xa3a0
leaq 0x6d12f(%rip), %rcx     # 0x9a3d0
movq %rax, (%rcx)
leaq 0x6d12d(%rip), %rcx     # 0x9a3d8
movq %rax, (%rcx)
jmp 0x2d2da
lock
incl 0x8(%r14)
movq 0x18(%rax), %rdi
callq 0xa3a0
leaq 0x6d10b(%rip), %rcx     # 0x9a3d0
movq %rax, (%rcx)
leaq 0x6d109(%rip), %rcx     # 0x9a3d8
movq %rax, (%rcx)
movq %r14, %rdi
callq 0xdce4
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %rdi
callq 0xa350
leaq 0x6d0d9(%rip), %rbx     # 0x9a3d0
movq (%rbx), %rdi
callq 0xa350
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x6d0cd(%rip), %rcx     # 0x9a3d8
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2d38b
movq %rbx, %rdi
callq 0xa380
movq %rsp, %rdi
movq %rax, %rsi
callq 0x14f76
movq %rbx, %rdi
callq 0xa170
movq %rsp, %rdi
callq 0x20470
movq 0x6cc68(%rip), %rdi     # 0x99fb0
callq 0xa1a0
movq %rax, %rbx
leaq 0x4b4ba(%rip), %rsi     # 0x78811
movl $0x30, %edx
movq %rax, %rdi
callq 0xa320
movq %rbx, %rdi
callq 0xa1a0
movq %rsp, %rdi
callq 0x14b26
callq 0xa4c0
jmp 0x2d30e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x14b26
callq 0xa4c0
movq %rbx, %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcd8
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgStrWithEscapedNames(CppProgram*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void addToProgStrWithEscapedNames(CppProgram * prog, string str)
{
	int i=0;
	string buffer = "";
	
	while (i < (int)str.size())
	{
		if (str[i] == '$')
		{
			i++;
			prog->code(buffer);
			buffer = "";
			while (i < (int)str.size())
			{
				char c = str[i];
				
				if (!(
					(c >= '0' && c <= '9') ||
					(c >= 'a' && c <= 'z') ||
					(c >= 'A' && c <= 'Z')
				)) break;
				
				buffer += c;
				i++;
			}
			if (buffer.empty())
				prog->code("$");
			else
				prog->name(buffer);
			buffer = "";
		}
		else
		{
			buffer += str[i];
			i++;
		}
	}
	
	prog->code(buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x46250(%rip), %rdx     # 0x77a4f
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xdfa8
cmpl $0x0, 0x8(%r14)
jle 0x31920
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
leaq 0x4622a(%rip), %r12     # 0x77a4f
movslq %ebp, %r13
movq (%r14), %rax
movb (%rax,%r13), %al
cmpb $0x24, %al
jne 0x31896
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x1861a
movq 0x10(%rsp), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xa470
incq %r13
movq %r13, %rbp
leaq 0x28(%rsp), %r13
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jge 0x318a5
movq (%r14), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x31886
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jae 0x318a5
incq %rbp
movsbl %al, %esi
movq %r15, %rdi
callq 0xa290
jmp 0x31862
movsbl %al, %esi
movq %r15, %rdi
callq 0xa290
incl %ebp
jmp 0x31916
cmpq $0x0, 0x10(%rsp)
je 0x318be
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x1889c
jmp 0x31901
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r13, %rdi
leaq 0x49173(%rip), %rsi     # 0x7aa45
leaq 0x4916d(%rip), %rdx     # 0x7aa46
callq 0xdfa8
movq 0xa0(%rbx), %rdi
movq %r13, %rsi
callq 0x1861a
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x31901
callq 0xa2b0
movq 0x10(%rsp), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xa470
cmpl 0x8(%r14), %ebp
jl 0x31825
movq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1861a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x31945
callq 0xa2b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31973
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x31976
callq 0xa2b0
jmp 0x31976
jmp 0x31973
jmp 0x31973
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3198a
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: populatePhplusStdLib()
void populatePhplusStdLib()
{
	basicSetup();
	populateBasicTypes();
	populateConstants();
	populateOperators();
	populateConverters();
	populateStdFuncs();
	populateTypeInfoFuncs();
	populateMemManagementFuncs();
	populateStringFuncs();
	populateIntArrayAndFuncs();
	populateArrayFuncs();
	populateNonStdFuncs();
	populateCppInterfaceFuncs();
}

// Assembly:
pushq %rax
callq 0x31992
callq 0x31a3f
callq 0x320d9
callq 0x332ba
callq 0x372c9
callq 0x3ad50
callq 0x3ba3a
callq 0x3bd64
callq 0x3c246
callq 0x3ef8c
callq 0x3e03c
callq 0x3fb52
popq %rax
jmp 0x403c6
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstWhatevToActionFactory::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstWhatevToActionFactory;
		copyToNode(out, copyCache);
		out->lambda=lambda;
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xa2d0
movq %rax, %r15
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
xorl %eax, %eax
movb %al, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
movb %al, 0x68(%r15)
movups %xmm0, 0x70(%r15)
movb %al, 0x80(%r15)
leaq 0x48300(%rip), %rax     # 0x97f88
movq %rax, (%r15)
movl $0x88, %r12d
leaq (%r15,%r12), %r13
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
addq %r14, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x4fb9a
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstWhatevToActionFactory::makeCopyWithSpecificTypes(std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
AstNode makeCopyWithSpecificTypes(Type leftInType, Type rightInType)
	{
		auto action=lambda(leftInType, rightInType);
		if (action)
			return AstActionWrapper::make(action);
		else
			return nullptr;
	}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdx), %rsi
movq %rsi, 0x30(%rsp)
movq 0x8(%rdx), %rdx
movq %rdx, 0x38(%rsp)
testq %rdx, %rdx
je 0x4fd10
movq 0x4a2a6(%rip), %rsi     # 0x99fa8
cmpb $0x0, (%rsi)
je 0x4fd0c
incl 0x8(%rdx)
jmp 0x4fd10
lock
incl 0x8(%rdx)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x4fd3b
movq 0x4a27b(%rip), %rdx     # 0x99fa8
cmpb $0x0, (%rdx)
je 0x4fd37
incl 0x8(%rcx)
jmp 0x4fd3b
lock
incl 0x8(%rcx)
cmpq $0x0, 0x98(%rax)
je 0x4fe06
leaq 0x88(%rax), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *0xa0(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4fd74
callq 0xdce4
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4fd83
callq 0xdce4
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x4fdb2
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x4fdbf
movq 0x4a200(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x4fdbb
incl 0x8(%rax)
jmp 0x4fdbf
movq $0x0, (%rbx)
jmp 0x4fdee
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x25fa8
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4fdee
callq 0xdce4
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4fdfd
callq 0xdce4
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
callq 0xa140
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe1d
callq 0xdce4
movq 0x48(%rsp), %rdi
jmp 0x4fe3b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe36
callq 0xdce4
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe45
callq 0xdce4
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: cppStr2PncnStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline void* cppStr2PncnStr(string cpp)
{
	void * obj=malloc(String->getSize());
	char * strData=(char*)malloc(cpp.size()*sizeof(char));
	memcpy(strData, cpp.c_str(), cpp.size()*sizeof(char));
	
	*((int*)((char*)obj+String->getSubType("_size").offset))=cpp.size();
	*((char**)((char*)obj+String->getSubType("_data").offset))=strData;
	
	return obj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r12
leaq 0x4a082(%rip), %r13     # 0x9a460
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rdi
callq 0xa3a0
movq %rax, %rbx
movq 0x8(%r12), %r15
movq %r15, %rdi
callq 0xa3a0
movq %rax, %r14
movq (%r12), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0xa270
movq (%r13), %r12
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2a621(%rip), %rsi     # 0x7aa47
leaq 0x2a61f(%rip), %rdx     # 0x7aa4c
leaq 0x38(%rsp), %rdi
callq 0xdfa8
movq (%r12), %rax
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
movq %r12, %rsi
callq *0x50(%rax)
movq (%rsp), %rax
movl %r15d, (%rbx,%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x50460
callq 0xdce4
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5046f
callq 0xa2b0
movq (%r13), %r15
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2a94a(%rip), %rsi     # 0x7adce
leaq 0x2a948(%rip), %rdx     # 0x7add3
leaq 0x18(%rsp), %rdi
callq 0xdfa8
movq (%r15), %rax
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
movq %r15, %rsi
callq *0x50(%rax)
movq (%rsp), %rax
movq %r14, (%rbx,%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x504bd
callq 0xdce4
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x504cc
callq 0xa2b0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
jne 0x504fc
jmp 0x50506
jmp 0x50503
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x50506
callq 0xa2b0
jmp 0x50506
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: pncnStr2CppStr[abi:cxx11](void*)
inline string pncnStr2CppStr(void* obj)
{
	int len=getValFromTuple<int>(obj, String, "_size");
	char * data=(char*)malloc((len+1)*sizeof(char));
	memcpy(data, getValFromTuple<char*>(obj, String, "_data"), len*sizeof(char));
	data[len]=0;
	string out(data);
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x49f38(%rip), %r13     # 0x9a460
movq (%r13), %rcx
movq 0x8(%r13), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x50554
movq 0x49a62(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x50550
incl 0x8(%rax)
jmp 0x50554
lock
incl 0x8(%rax)
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a4e3(%rip), %rsi     # 0x7aa47
leaq 0x2a4e1(%rip), %rdx     # 0x7aa4c
leaq 0x50(%rsp), %rdi
callq 0xdfa8
leaq 0x20(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x506b8
movl %eax, %r12d
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x50599
callq 0xa2b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x505a8
callq 0xdce4
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0xa3a0
movq %rax, %r15
movq (%r13), %rcx
movq 0x8(%r13), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x505e4
movq 0x499d2(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x505e0
incl 0x8(%rax)
jmp 0x505e4
lock
incl 0x8(%rax)
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2a7da(%rip), %rsi     # 0x7adce
leaq 0x2a7d8(%rip), %rdx     # 0x7add3
leaq 0x30(%rsp), %rdi
callq 0xdfa8
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x50945
movslq %r12d, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xa270
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x50637
callq 0xa2b0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x50646
callq 0xdce4
movb $0x0, (%r15,%r14)
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa160
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x50683
callq 0xa2b0
jmp 0x50683
movq %rax, %rbx
movq 0x18(%rsp), %rdi
jmp 0x506a6
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x506a1
callq 0xa2b0
jmp 0x506a1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x506b0
callq 0xdce4
movq %rbx, %rdi
callq 0xa510