LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppNameContainer::getCpp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CppNameContainer::getCpp(const string& pp)
{
	auto result=ppToCppMap.find(pp);
	
	if (result==ppToCppMap.end())
	{
		if (parent)
			return parent->getCpp(pp);
		else
			throw PhplusError("could not find C++ equivalent of '"+pp+"' in CppNameContainer::getCppForPp", INTERNAL_ERROR);
	}
	else
		return result->second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x18ac6
leaq 0x40(%r15), %rcx
cmpq %rcx, %rax
jne 0x14438
movq 0x68(%r15), %r15
testq %r15, %r15
jne 0x143b1
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x405f7(%rip), %rsi     # 0x549d8
leaq 0x18(%rsp), %rdi
movq %r14, %rdx
callq 0xc8a1
leaq 0x40606(%rip), %rdx     # 0x549fb
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc882
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x6316f(%rip), %rsi     # 0x77598
leaq -0x2d9e(%rip), %rdx     # 0x11692
movq %rbx, %rdi
callq 0xa4e0
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa3b0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc984
leaq 0x38(%rsp), %rdi
callq 0xa558
jmp 0x14474
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x14488
jmp 0x14490
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::CppFuncBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<CppNameContainer>, bool)
CppFuncBase::CppFuncBase(string prototypeIn, shared_ptr<CppNameContainer> myNames, bool returnsValIn)
{
	prototype=prototypeIn;
	namespaceStack.push_back(myNames);
	freshLine=true;
	returnsVal=returnsValIn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x40566(%rip), %rsi     # 0x54a1e
leaq 0x7(%rsp), %rdx
callq 0xa150
movb $0x1, 0x20(%rbx)
andq $0x0, 0x24(%rbx)
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
xorl %eax, %eax
movb %al, 0x40(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
leaq 0x30(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movb %al, 0x60(%rbx)
leaq 0x80(%rbx), %rcx
movq %rcx, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movb %al, 0x80(%rbx)
andw $0x0, 0x90(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rbx), %r15
leaq 0x98(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
andq $0x0, 0xa8(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa1d0
movq %r13, %rdi
movq %r14, %rsi
callq 0x18284
movb $0x1, 0x20(%rbx)
movb %bpl, 0x90(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x18340
movq %r15, %rdi
callq 0xa558
movq 0x8(%rsp), %rdi
callq 0xa558
movq 0x10(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::code(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CppFuncBase::code(const string& in)
{
	if (freshLine)
	{
		source+=indentString(in, indent, blockLevel);
		freshLine=(in.back()=='\n');
	}
	else if (searchInString(in, "\n")>0)
	{
		source+="\n"+indentString(in, indent, blockLevel);
		if (in.back()!='\n')
			source+="\n";
		freshLine=true;
	}
	else
	{
		source+=in;
		freshLine=(in.back()=='\n');
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x14605
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa3b0
movl 0x24(%rbx), %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x41afa
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x68(%rsp), %rdi
callq 0xa558
jmp 0x146d4
leaq 0x408ec(%rip), %rsi     # 0x54ef8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x41940
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xa558
testl %ebp, %ebp
jle 0x146c8
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa3b0
movl 0x24(%rbx), %ecx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x41afa
leaq 0x40890(%rip), %rsi     # 0x54ef8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x11ff8
leaq 0x50(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x48(%rsp), %rdi
callq 0xa558
movq (%r14), %rax
movq 0x8(%r14), %rcx
movb $0x1, %bpl
cmpb $0xa, -0x1(%rax,%rcx)
je 0x146e4
leaq 0x4083a(%rip), %rsi     # 0x54ef8
movq %r15, %rdi
callq 0xa520
jmp 0x146e4
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0xa540
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpb $0xa, -0x1(%rax,%rcx)
sete %bpl
movb %bpl, 0x20(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x14708
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x14717
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x14744
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x14744
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x1473f
movq %rax, %rbx
jmp 0x14749
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::endln()
void CppFuncBase::endln()
{
	if (exprLevel>0)
	{
		throw PhplusError("non zero expression level when ending line in C++ program, code so far:\n"+indentString(source), INTERNAL_ERROR);
	}
	else if (freshLine && (source.size()<2 || source[source.size()-2]==';' || source[source.size()-2]=='}' || source[source.size()-2]=='{'))
	{
		// do nothing
		
		//source+=indentString("\n", indent, blockLevel);
	}
	else
	{
		source+=";\n";
	}
	
	freshLine=true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
cmpl $0x0, 0x28(%rdi)
jg 0x1481a
cmpb $0x1, 0x20(%r14)
jne 0x147f9
movq 0x58(%r14), %rax
cmpq $0x2, %rax
jb 0x14809
movq 0x50(%r14), %rcx
movzbl -0x2(%rcx,%rax), %eax
cmpl $0x3b, %eax
je 0x14809
cmpl $0x7b, %eax
je 0x14809
cmpl $0x7d, %eax
je 0x14809
leaq 0x50(%r14), %rdi
leaq 0x42f8f(%rip), %rsi     # 0x57793
callq 0xa520
movb $0x1, 0x20(%r14)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x4023d(%rip), %rsi     # 0x54a69
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
addq $0x50, %r14
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x41afa
leaq 0x401c5(%rip), %rsi     # 0x54a20
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x11ff8
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x62d07(%rip), %rsi     # 0x77598
leaq -0x3206(%rip), %rdx     # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x60(%rsp), %rdi
callq 0xa558
jmp 0x148bf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0xa558
jmp 0x148d1
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x148e5
jmp 0x148ed
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::comment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CppFuncBase::comment(const string& in)
{
	if (searchInString(in, "\n")>=0)
	{
		source+=indentString("\n/*\n"+in+"\n*/\n", indent, blockLevel);
		freshLine=true;
	}
	else if (exprLevel>0 || !freshLine)
	{
		source+="/* "+in+" */";
		freshLine=false;
	}
	else
	{
		source+=indentString("// "+in+"\n", indent, blockLevel);
		freshLine=true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x405e8(%rip), %rsi     # 0x54ef8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x41940
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xa558
testl %ebp, %ebp
js 0x149d9
leaq 0x40125(%rip), %rsi     # 0x54a6e
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xc8a1
leaq 0x40113(%rip), %rdx     # 0x54a73
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xc882
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0xa3b0
movl 0x24(%rbx), %ecx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x41afa
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x88(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x48(%rsp), %rdi
callq 0xa558
movb $0x1, 0x20(%rbx)
jmp 0x14aa7
cmpl $0x0, 0x28(%rbx)
jg 0x14a56
cmpb $0x0, 0x20(%rbx)
je 0x14a56
leaq 0x40090(%rip), %rsi     # 0x54a7c
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xc8a1
leaq 0x404f5(%rip), %rdx     # 0x54ef8
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xc882
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0xa3b0
movl 0x24(%rbx), %ecx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x41afa
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x68(%rsp), %rdi
jmp 0x149b7
leaq 0x4001b(%rip), %rsi     # 0x54a78
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xc8a1
leaq 0x43dec(%rip), %rdx     # 0x58860
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xc882
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xa558
movb $0x0, 0x20(%rbx)
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x14ac7
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x14b05
jmp 0x14b0c
jmp 0x14b1b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x14ae4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x14b2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x14afd
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xa558
jmp 0x14b0f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x14b1e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x14b2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x14b32
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::popExpr()
void CppFuncBase::popExpr()
{
	if (exprLevel<=0)
	{
		throw PhplusError("CppProgram::popExpression called with zero expressionLevel", INTERNAL_ERROR);
	}
	
	code(")");
	exprLevel--;
	freshLine=false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpl $0x0, 0x28(%rdi)
jle 0x14bea
movq %rdi, %rbx
leaq 0x438e5(%rip), %rsi     # 0x58499
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x145a2
leaq 0x10(%rsp), %rdi
callq 0xa558
decl 0x28(%rbx)
movb $0x0, 0x20(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x3fe84(%rip), %rsi     # 0x54a80
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x62966(%rip), %rsi     # 0x77598
leaq -0x35a7(%rip), %rdx     # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x14c62
jmp 0x14c7e
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
jmp 0x14c7e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x14c7e
movq %rax, %r14
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/CppProgram.cpp
// Function: CppFuncBase::pushBlock()
void CppFuncBase::pushBlock()
{
	if (exprLevel>0)
	{
		throw PhplusError("CppProgram::pushBlock called when expressionLevel was not zero", INTERNAL_ERROR);
	}
	
	{
		code("{\n");
		namespaceStack.push_back(namespaceStack.back()->makeChild());
		blockLevel++;
		freshLine=true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
cmpl $0x0, 0x28(%rdi)
jg 0x14d0c
movq %rdi, %rbx
leaq 0x40130(%rip), %rsi     # 0x54dd0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x145a2
leaq 0x10(%rsp), %rdi
callq 0xa558
leaq 0x98(%rbx), %r14
movq 0xa0(%rbx), %rax
movq -0x10(%rax), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x13d84
movq %r14, %rdi
movq %r15, %rsi
callq 0x192e0
leaq 0x18(%rsp), %rdi
callq 0xc984
incl 0x24(%rbx)
movb $0x1, 0x20(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x3fd9d(%rip), %rsi     # 0x54abb
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x62844(%rip), %rsi     # 0x77598
leaq -0x36c9(%rip), %rdx     # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x14d84
jmp 0x14daf
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
jmp 0x14daf
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xc984
jmp 0x14daf
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x14daf
movq %rax, %r14
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x14e15
movq %rdi, %rbx
decl %eax
movl %eax, 0x24(%rdi)
addq $0x98, %rdi
callq 0x18362
leaq 0x401fa(%rip), %rsi     # 0x54fdc
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x145a2
leaq 0x10(%rsp), %rdi
callq 0xa558
movb $0x1, 0x20(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x3fcd3(%rip), %rsi     # 0x54afa
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x6273b(%rip), %rsi     # 0x77598
leaq -0x37d2(%rip), %rdx     # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x14e8d
jmp 0x14ea9
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
jmp 0x14ea9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x14ea9
movq %rax, %r14
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0xf8(%rdi), %rdi
callq 0x142a2
testb %al, %al
jne 0x170bb
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x12c0a
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x15e88
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa540
leaq 0x10(%rsp), %rdi
callq 0xa558
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x3da70(%rip), %rsi     # 0x54a6c
leaq 0x30(%rsp), %rdi
callq 0xa520
movq 0xf8(%rbx), %r12
leaq 0x3d901(%rip), %rsi     # 0x54915
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x13de2
leaq 0x10(%rsp), %rdi
callq 0xa558
movq 0xf8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x1439e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa540
leaq 0x10(%rsp), %rdi
callq 0xa558
cmpq $0x0, 0x8(%r14)
je 0x1708f
leaq 0x4099a(%rip), %rsi     # 0x57a12
leaq 0x30(%rsp), %rdi
callq 0xa520
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xa540
leaq 0x406fd(%rip), %rsi     # 0x57793
leaq 0x30(%rsp), %rdi
callq 0xa520
addq $0x60, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xa540
leaq 0x30(%rsp), %rdi
callq 0xa558
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x170cd
jmp 0x170fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x170ff
jmp 0x170fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x170f0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xc984
jmp 0x170ff
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x4, %esi
ja 0x19a51
movl %esi, %eax
leaq 0x3b72e(%rip), %rcx     # 0x55130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3b756(%rip), %rsi     # 0x55168
leaq 0xf(%rsp), %rdx
jmp 0x19a5d
leaq 0x3b740(%rip), %rsi     # 0x55160
leaq 0xb(%rsp), %rdx
jmp 0x19a5d
leaq 0x3b71e(%rip), %rsi     # 0x5514c
leaq 0xd(%rsp), %rdx
jmp 0x19a5d
leaq 0x3b715(%rip), %rsi     # 0x55151
leaq 0xc(%rsp), %rdx
jmp 0x19a5d
leaq 0x3b6fa(%rip), %rsi     # 0x55144
leaq 0xe(%rsp), %rdx
jmp 0x19a5d
leaq 0x3b716(%rip), %rsi     # 0x5516e
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movb $0x20, (%r14)
movq %r14, %rsi
callq 0x1ac26
andl $0x0, (%rax)
movb $0x9, (%r14)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ac26
andl $0x0, (%rax)
movb $0xa, (%r15)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ac26
movl $0x2, (%rax)
movb $0x3b, (%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac26
movl $0x1, (%rax)
movb $0x61, %al
movb %al, 0x8(%rsp)
cmpb $0x7b, %al
jge 0x1a089
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1af00
movl $0x3, (%rax)
movb 0x8(%rsp), %al
incb %al
jmp 0x1a068
movb $0x41, %al
leaq 0x8(%rsp), %r14
movb %al, 0x8(%rsp)
cmpb $0x5b, %al
jge 0x1a0b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1af00
movl $0x3, (%rax)
movb 0x8(%rsp), %al
incb %al
jmp 0x1a090
leaq 0x8(%rsp), %r14
movb $0x5f, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ac26
movl $0x3, (%rax)
movb $0x30, %al
movb %al, 0x8(%rsp)
cmpb $0x3a, %al
jge 0x1a0ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1af00
movl $0x4, (%rax)
movb 0x8(%rsp), %al
incb %al
jmp 0x1a0cd
leaq 0x8(%rsp), %r14
movb $0x23, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ac26
movl $0x7, (%rax)
movb $0x22, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac26
movl $0x6, (%rax)
leaq 0x601ca(%rip), %rax     # 0x7a2f0
movl $0x200, %r15d           # imm = 0x200
addq (%rax), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1a175
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xa3b0
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %r12, 0x10(%rsp)
jbe 0x1a16b
movq 0x8(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x1af00
movl $0x5, (%rax)
incl %r12d
jmp 0x1a146
movq %r14, %rdi
callq 0xa558
jmp 0x1a12f
movb $0x1, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Lexer.cpp
// Function: CharClassifier::get(std::shared_ptr<SourceFile>, int)
inline CharClassifier::Type CharClassifier::get(shared_ptr<SourceFile> file, int index)
{
	//	set up the first time this function is called
	if (!hasSetUp)
		setUp();
	
	//	chack fo multi line comments in a special way, because they are multi character
	
	switch ((*file)[index])
	{
	case '/':
		if (index<int(file->size())-1 && (*file)[index+1]=='/')
			return MULTI_LINE_COMMENT_START;
		break;
		
	case '\\':
		if (index>0 && (*file)[index-1]=='\\')
			return MULTI_LINE_COMMENT_END;
		break;
		
	case '.': // allow a . to be a digit character only if it is followed by a digit
		if (index<int(file->size())-1)
		{
			auto i=hm.find((*file)[index+1]);
		
			if (i!=hm.end() && i->second==DIGIT)
				return DIGIT;
		}
		break;
	}
	
	//	handle all other cases using the hashmap
	char c=(*file)[index];
	
	auto i=hm.find(c);
	
	if (i==hm.end())
		return UNKNOWN;
	else
		return i->second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x38(%rdi)
jne 0x1a8e7
movq %rbx, %rdi
callq 0x19ffc
movq (%r14), %rcx
movslq %ebp, %r15
movq 0x20(%rcx), %rax
movzbl (%rax,%r15), %edx
cmpl $0x2e, %edx
je 0x1a92b
cmpl $0x5c, %edx
je 0x1a91a
cmpl $0x2f, %edx
jne 0x1a957
movl 0x28(%rcx), %ecx
decl %ecx
cmpl %ebp, %ecx
jle 0x1a957
cmpb $0x2f, 0x1(%rax,%r15)
jne 0x1a957
pushq $0x8
jmp 0x1a97d
testl %ebp, %ebp
jle 0x1a957
movl %ebp, %ecx
cmpb $0x5c, -0x1(%rax,%rcx)
jne 0x1a957
pushq $0x9
jmp 0x1a97d
movl 0x28(%rcx), %ecx
decl %ecx
cmpl %ebp, %ecx
jle 0x1a957
movb 0x1(%rax,%r15), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1aba8
testq %rax, %rax
je 0x1a957
cmpl $0x4, 0xc(%rax)
jne 0x1a957
pushq $0x4
jmp 0x1a97d
movq (%r14), %rax
movq 0x20(%rax), %rax
movb (%rax,%r15), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x1aba8
testq %rax, %rax
je 0x1a97b
movl 0xc(%rax), %eax
jmp 0x1a97e
pushq $0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
cmpl $0x4, %esi
je 0x1a9b9
movl %esi, %eax
cmpl $0x7, %esi
je 0x1a9a9
cmpl $0x6, %eax
jne 0x1a9c9
xorl %ecx, %ecx
cmpl $0x2, %edi
pushq $0x6
jmp 0x1a9b0
xorl %ecx, %ecx
cmpl $0x9, %edi
pushq $0x7
popq %rax
cmovel %ecx, %eax
jmp 0x1aa57
xorl %eax, %eax
cmpl $0x6, %edi
setne %al
shll $0x2, %eax
jmp 0x1aa57
cmpl $0x9, %edi
ja 0x1aa48
movl %edi, %ecx
leaq 0x3a7d1(%rip), %rdx     # 0x551a8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %edi, %eax
jmp 0x1aa57
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
je 0x1aa57
xorl %eax, %eax
cmpl $0x4, %edi
sete %al
orl $0x2, %eax
jmp 0x1aa57
pushq $0x1
jmp 0x1aa56
leaq 0x3a7e6(%rip), %rsi     # 0x551ec
leaq 0x20(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x5f8d1(%rip), %rdi     # 0x7a2fb
movq %rbx, %rsi
xorl %edx, %edx
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
pushq $0xb
jmp 0x1aa56
pushq $0x6
jmp 0x1aa56
pushq $0x4
jmp 0x1aa56
pushq $0x7
popq %rax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1e2ca
testq %rax, %rax
jne 0x1b2c8
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e39a
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x1e25e
movq %r12, %rdi
callq 0x1df42
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e39a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12fa6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1df42
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x1e2ca
testq %rax, %rax
je 0x1b34c
movq %rax, %r14
xorl %eax, %eax
movq %rsp, %r15
movl %eax, %r12d
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x1b34c
movq (%rax,%r12,8), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e6fc
leal 0x1(%r12), %eax
jmp 0x1b31b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::getStringWithParents[abi:cxx11]()
string NamespaceData::getStringWithParents()
{
	auto ptr=shared_from_this();
	
	string out;
	
	while (ptr)
	{
		out=putStringInBox(ptr->getString()+"\n"+out, ptr->myName);
		ptr=ptr->parent;
	}
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1eb38
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %r13
leaq 0x78(%rsp), %rbp
leaq 0x18(%rsp), %r14
leaq 0x98(%rsp), %r12
cmpq $0x0, 0x8(%rsp)
je 0x1b8f3
movq %r15, %rdi
callq 0x1b7e0
movq %r13, %rdi
movq %r15, %rsi
leaq 0x3968b(%rip), %rdx     # 0x54ef8
callq 0xc882
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x184b5
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq %r14, %rdi
callq 0xa3b0
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq $-0x1
popq %r9
callq 0x42deb
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa350
movq %r12, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa558
movq %rbp, %rdi
callq 0xa558
movq %r13, %rdi
callq 0xa558
movq %r15, %rdi
callq 0xa558
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
leaq 0x8(%rsp), %rdi
callq 0x12bda
jmp 0x1b84c
leaq 0x10(%rsp), %rdi
callq 0xc984
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1b942
movq %rax, %r14
jmp 0x1b938
movq %rax, %r14
jmp 0x1b92e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xa558
leaq 0x78(%rsp), %rdi
callq 0xa558
leaq 0x58(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0xa558
jmp 0x1b951
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xc984
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Namespace.cpp
// Function: NamespaceData::addNode(std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void NamespaceData::addNode(AstNode node, string id)
{
	if (node->nameHint.empty())
	{
		node->nameHint=id;
		node->nameHintSet();
	}
	
	if (node->isType())
	{
		types.add(id, move(node));
	}
	/*
	else if (id=="__destroy__")
	{
		Action action=node->getAction();
		if (action->getInRightType()->isVoid() || !action->getInLeftType()->isVoid() || !action->getReturnType()->isVoid())
		{
			throw PhplusError("incorrect type signiture for destroyer", SOURCE_ERROR, node->getToken());
		}
		destructors.add(str::ptrToUniqueStr(&*action->getInRightType(), 6), move(node));
	}
	else if (id=="__copy__")
	{
		Action action=node->getAction();
		if (action->getInRightType()->isVoid() || !action->getInLeftType()->isVoid() || action->getReturnType()!=action->getInRightType())
		{
			throw PhplusError("incorrect type signiture for copier", SOURCE_ERROR, node->getToken());
		}
		copiers.add(str::ptrToUniqueStr(&*action->getReturnType(), 6), move(node));
	}
	*/
	else
	{
		// if the left or the right is a Whatev and the types match up
		if (node->canBeWhatev())
		{
			whatevActions.add(id, move(node));
		}
		else
		{
			actions.add(id, move(node));
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
cmpq $0x0, 0x10(%rdi)
jne 0x1c128
addq $0x8, %rdi
movq %r12, %rsi
callq 0xa1d0
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x1c169
addq $0xf8, %rbx
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3b0
movq (%r14), %rax
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
andq $0x0, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b27c
jmp 0x1c1dd
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x1c1ad
addq $0xc0, %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3b0
movq (%r14), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
andq $0x0, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b27c
jmp 0x1c1dd
addq $0x50, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3b0
movq (%r14), %rax
movq %rsp, %r12
movq %rax, (%r12)
andq $0x0, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b27c
movq %r12, %rdi
callq 0x11c58
movq %r15, %rdi
callq 0xa558
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %rsp, %rdi
jmp 0x1c222
movq %rax, %rbx
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %rdi
jmp 0x1c222
movq %rax, %rbx
leaq 0x58(%rsp), %r14
leaq 0x10(%rsp), %rdi
callq 0x11c58
movq %r14, %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x388a5(%rip), %rsi     # 0x5533d
leaq 0x60(%rsp), %r12
leaq 0x1f(%rsp), %rdx
movq %r12, %rdi
callq 0xa150
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x3cfa4
leaq 0x5d922(%rip), %rsi     # 0x7a3e0
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x12c0a
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c0a
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x1d016
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x60(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
jmp 0x1cb7e
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38781(%rip), %rsi     # 0x55331
leaq 0x60(%rsp), %r12
leaq 0x1f(%rsp), %rdx
movq %r12, %rdi
callq 0xa150
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x3cfa4
leaq 0x5d80a(%rip), %rsi     # 0x7a3e0
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x12c0a
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c0a
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x1d016
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x60(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
jmp 0x1cc96
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
testl %ecx, %ecx
je 0x1dd3a
leaq 0x50(%rbx), %rbp
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xa3b0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1b2fe
leaq 0x68(%rsp), %rdi
callq 0xa558
cmpb $0x0, 0x4(%rsp)
je 0x1dd70
leaq 0x88(%rbx), %rbp
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xa3b0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1b2fe
leaq 0x48(%rsp), %rdi
callq 0xa558
cmpb $0x0, (%rsp)
je 0x1dda5
leaq 0xc0(%rbx), %rbp
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xa3b0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1b2fe
leaq 0x28(%rsp), %rdi
callq 0xa558
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0x1dde5
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xa3b0
movzbl %r15b, %ecx
movzbl 0x4(%rsp), %r8d
movzbl (%rsp), %r9d
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1dce4
leaq 0x8(%rsp), %rdi
callq 0xa558
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ddfd
jmp 0x1ddfd
jmp 0x1ddfd
movq %rax, %rbx
movq %r13, %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, %r12
movq %rsi, 0x10(%rsp)
movq (%rdx), %r15
movq 0x8(%rdx), %rbx
movq %rsp, %r13
leaq 0x28(%rsp), %rbp
cmpq %rbx, %r15
je 0x1deff
movq (%r15), %rsi
movq %r13, %rdi
callq 0x1189c
movq (%rsp), %rax
movq 0x38(%rax), %r14
movq %rbp, %rdi
movq %r12, %rsi
callq 0x12c0a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3de4c
testb %al, %al
je 0x1dee2
movq %r15, 0x20(%rsp)
movq %rbp, %r15
movq %rbx, %rbp
movq %r12, %rbx
movq %r13, %r12
movq (%rsp), %rax
movq 0x48(%rax), %r14
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq 0x18(%rsp), %rsi
callq 0x12c0a
movq %r14, %rdi
movq %r13, %rsi
callq 0x3de4c
movl %eax, %r14d
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
testb %r14b, %r14b
movq %r12, %r13
movq %rbx, %r12
movq %rbp, %rbx
movq %r15, %rbp
movq 0x20(%rsp), %r15
je 0x1deec
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x1198c
jmp 0x1deec
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x8(%rsp), %rdi
callq 0xc984
addq $0x8, %r15
jmp 0x1de3a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1df2f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc984
jmp 0x1df25
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x8(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0xa2c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1e10a
movq %r14, (%rbx)
movq (%r15), %rsi
addq $0x38, %rsi
leaq 0x28(%r14), %rdi
callq 0x12ba2
movq (%r15), %rsi
addq $0x48, %rsi
leaq 0x38(%r14), %rdi
callq 0x12ba2
movq (%r15), %rsi
addq $0x28, %rsi
leaq 0x58(%r14), %rdi
callq 0x12ba2
leaq 0x48(%r14), %rdi
movq %r15, %rsi
callq 0x12bbe
movb $0x1, %bpl
movb %bpl, 0x68(%r14)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r14, %rdi
addq $0x70, %rdi
callq 0x135d0
leaq 0x8(%rsp), %rdi
callq 0xc984
movb %bpl, 0x80(%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsi, %rdi
movl %edx, %esi
movl %ecx, %edx
movq %rax, %rcx
callq 0x1eca6
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x1ec4b
testq %rcx, %rcx
jne 0x1ec57
leaq 0x8(%rsp), %rdi
callq 0x21bcc
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, (%rbx)
callq 0x21c0a
jmp 0x1ec7a
movq (%rax), %rcx
movq %rcx, (%rbx)
andq $0x0, (%rax)
jmp 0x1ec7a
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21c24
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, (%rbx)
callq 0x21c76
leaq 0x10(%rsp), %rdi
callq 0x1df42
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x1ec91
jmp 0x1ec91
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1df42
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Parser.cpp
// Function: importFile(std::vector<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::allocator<std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void importFile(vector<AstNode>& nodes, string path)
{
	auto file=shared_ptr<SourceFile>(new SourceFile(path, false));
	
	if (file->getContents().empty())
	{
		throw PhplusError("file '"+path+"' failed to open or was empty", SOURCE_ERROR);
	}
	
	vector<Token> tokens;
	
	lexString(file, tokens);
	
	parseTokenList(tokens, 0, tokens.size()-1, nodes);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0xa2c0
movq %rax, %r15
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0xa3b0
movb $0x1, %bpl
leaq 0x58(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3c4bc
xorl %ebp, %ebp
movq %rsp, %rdi
movq %r15, %rsi
callq 0x22660
leaq 0x58(%rsp), %rdi
callq 0xa558
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21ad6
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x19fe6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a19a
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
subq (%rdi), %rdx
shrq $0x4, %rdx
decl %edx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1eca6
leaq 0x10(%rsp), %rdi
callq 0x22086
leaq 0x8(%rsp), %rdi
callq 0xc984
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x33bcd(%rip), %rsi     # 0x556b5
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0xc8a1
leaq 0x33bc0(%rip), %rdx     # 0x556bc
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc882
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19f06
xorl %ebp, %ebp
leaq 0x55a67(%rip), %rsi     # 0x77598
leaq -0x104a6(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x78(%rsp), %rdi
callq 0xa558
jmp 0x21b5f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x21b73
jmp 0x21b99
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
jmp 0x21b99
movq %rax, %r14
jmp 0x21b8f
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
callq 0x22086
leaq 0x8(%rsp), %rdi
callq 0xc984
jmp 0x21bc4
movq %rax, %r14
jmp 0x21bbc
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
je 0x21bc4
movq %r15, %rdi
callq 0xa2a0
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0xc8, %edi
callq 0xa2c0
movq %rax, %r15
movq %rax, %rdi
callq 0x13242
movq %r15, (%r14)
leaq 0x98(%r15), %rdi
movq %r13, %rsi
callq 0x1e25e
leaq 0x88(%r15), %rdi
movq %r12, %rsi
callq 0x13172
addq $0xb0, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1e25e
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
nop