LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x260a6
testq %rax, %rax
jne 0x21980
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x261a2
leaq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movups (%rax), %xmm0
movq 0x10(%rax), %rcx
movq %rsp, %r12
movaps (%r12), %xmm1
movups %xmm1, (%rax)
movq 0x10(%r12), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rdi), %rax
movq %rcx, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r12)
movq %rax, 0x10(%r12)
callq 0x25cd8
movq %r12, %rdi
callq 0x25cd8
movq %r15, %rdi
movq %r14, %rsi
callq 0x261a2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16a7e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x25cd8
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x260a6
testq %rax, %rax
je 0x21a20
movq %rax, %r14
movq 0x28(%rax), %rax
cmpq %rax, 0x30(%r14)
je 0x21a20
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 0x219fd
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x21a08
movq %rbx, %rdi
movq %r15, %rdx
callq 0x264dc
movl %ebp, %ecx
movq 0x28(%r14), %rax
movq 0x30(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x219e1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x534c4(%rip), %rsi     # 0x772a4
leaq 0x534c5(%rip), %rdx     # 0x772ac
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xdf6a
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x53154
leaq 0x755f8(%rip), %rax     # 0x99400
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x23e33
movq 0x75183(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x23e2f
incl 0x8(%rax)
jmp 0x23e33
lock
incl 0x8(%rax)
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x23e5d
movq 0x75159(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x23e59
incl 0x8(%rax)
jmp 0x23e5d
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x30(%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 0x245c8
addq $0x10, %rsp
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x23e99
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23ea8
callq 0xdcba
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x23eb7
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x23ec6
callq 0xdcba
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x23ed5
callq 0xa2b0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x23ef8
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23f07
callq 0xdcba
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x23f16
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x23f2a
callq 0xdcba
jmp 0x23f2a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x23f39
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x53330(%rip), %rsi     # 0x77298
leaq 0x53334(%rip), %rdx     # 0x772a3
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xdf6a
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x53154
leaq 0x75470(%rip), %rax     # 0x99400
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x23fbb
movq 0x74ffb(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x23fb7
incl 0x8(%rax)
jmp 0x23fbb
lock
incl 0x8(%rax)
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x23fe5
movq 0x74fd1(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x23fe1
incl 0x8(%rax)
jmp 0x23fe5
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x30(%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 0x245c8
addq $0x10, %rsp
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x24021
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24030
callq 0xdcba
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2403f
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2404e
callq 0xdcba
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x2405d
callq 0xa2b0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x24080
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2408f
callq 0xdcba
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2409e
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x240b2
callq 0xdcba
jmp 0x240b2
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x240c1
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25a22
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 0xdde2
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219b6
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x25a22
callq 0xa2b0
cmpb $0x0, 0x4(%rsp)
je 0x25a74
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 0xdde2
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219b6
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x25a74
callq 0xa2b0
cmpb $0x0, (%rsp)
je 0x25ac5
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 0xdde2
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219b6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x25ac5
callq 0xa2b0
movq 0x30(%r13), %r13
testq %r13, %r13
je 0x25b1c
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 0xdde2
movzbl %r15b, %ecx
movzbl 0x4(%rsp), %r8d
movzbl (%rsp), %r9d
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x259b0
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x25b1c
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 0x25b59
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
jmp 0x25b59
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x25b63
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x25b5e
jmp 0x25b63
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x25c87
movq %r8, %rbx
movq %rcx, %r14
movq (%r15), %rsi
movq %rsp, %rdi
callq 0x14bb8
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x25be1
movq 0x733d5(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x25bdd
incl 0x8(%rax)
jmp 0x25be1
lock
incl 0x8(%rax)
leaq 0x20(%rsp), %rsi
callq 0x548ce
movl %eax, %ebp
testb %al, %al
je 0x25c20
movq (%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x25c29
movq 0x73392(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x25c25
incl 0x8(%rax)
jmp 0x25c29
xorl %r13d, %r13d
jmp 0x25c36
lock
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
callq 0x548ce
movl %eax, %r13d
testb %bpl, %bpl
je 0x25c4a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25c4a
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x25c59
callq 0xdcba
testb %r13b, %r13b
je 0x25c6b
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x14ce2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25c7a
callq 0xdcba
addq $0x8, %r15
cmpq %r12, %r15
jne 0x25ba3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25cb2
callq 0xdcba
jmp 0x25cb2
movq %rax, %rbx
jmp 0x25cc1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x25cc1
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25cd0
callq 0xdcba
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70f4c(%rip), %rax     # 0x96d00
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 0xde72
movq (%r15), %rsi
movq 0x48(%rsi), %rax
movq %rax, 0x38(%r14)
leaq 0x40(%r14), %rdi
addq $0x50, %rsi
callq 0xde72
movq (%r15), %rsi
movq 0x28(%rsi), %rax
movq %rax, 0x58(%r14)
leaq 0x60(%r14), %rdi
addq $0x30, %rsi
callq 0xde72
movq (%r15), %rax
movq %rax, 0x48(%r14)
leaq 0x50(%r14), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xde72
movb $0x1, 0x68(%r14)
movq 0x78(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
testq %rdi, %rdi
je 0x25e34
callq 0xdcba
movb $0x1, 0x80(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rax)
movq %rsi, %rdi
movl %edx, %esi
movl %ecx, %edx
movq %rax, %rcx
callq 0x26a47
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x269ec
testq %rcx, %rcx
jne 0x269fb
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 0x70441(%rip), %rcx     # 0x96e28
movq %rcx, (%rax)
jmp 0x26a18
movq (%rax), %rcx
movq %rcx, (%rbx)
movq $0x0, (%rax)
jmp 0x26a1b
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b490
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rax, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x25cd8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x26a32
jmp 0x26a32
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25cd8
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r13
movq %rdi, %r14
movl $0xc8, %edi
callq 0xa2d0
movq %rax, %r12
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq $0x0, 0x10(%r12)
xorl %eax, %eax
movb %al, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r12)
movups %xmm0, 0x38(%r12)
movups %xmm0, 0x48(%r12)
movups %xmm0, 0x58(%r12)
movb %al, 0x68(%r12)
movups %xmm0, 0x70(%r12)
movb %al, 0x80(%r12)
leaq 0x6b2ba(%rip), %rax     # 0x968f0
addq $0x10, %rax
movq %rax, (%r12)
movups %xmm0, 0x88(%r12)
movups %xmm0, 0x98(%r12)
movups %xmm0, 0xa8(%r12)
movups %xmm0, 0xb8(%r12)
movq %r12, (%r14)
leaq 0x98(%r12), %rdi
movq %r13, %rsi
callq 0x2bcb4
movq (%r15), %rax
movq %rax, 0x88(%r12)
leaq 0x90(%r12), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xde72
addq $0xb0, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2bcb4
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6b0d6(%rip), %rax     # 0x96868
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x88(%r14), %rdi
movups %xmm0, 0x88(%r14)
movq %r14, (%rbx)
movq (%r12), %rsi
movq %r13, (%r12)
callq 0x16bf4
movq (%r15), %rax
movq %r13, (%r15)
movq 0x90(%r14), %rsi
movq %rax, 0x90(%r14)
testq %rsi, %rsi
je 0x2b7e0
addq $0x90, %r14
movq %r14, %rdi
callq 0x168f8
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/../h/AstNode.h
// Function: AstExpression::make(std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>, std::unique_ptr<AstNodeBase, std::default_delete<AstNodeBase>>)
static unique_ptr<AstExpression> make(AstNode leftInIn, AstNode centerIn, AstNode rightInIn)
	{
		unique_ptr<AstExpression> node(new AstExpression);
		
		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 %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0xa0, %edi
callq 0xa2d0
movq %rax, %r14
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
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 0x6af62(%rip), %rcx     # 0x967e0
addq $0x10, %rcx
movq %rcx, (%r14)
movups %xmm0, 0x88(%r14)
movq %rax, 0x98(%r14)
movq %r14, (%rbx)
movq (%r13), %rcx
movq %rax, (%r13)
movq %rcx, 0x88(%r14)
movq (%r12), %rcx
movq %rax, (%r12)
movq 0x90(%r14), %rsi
movq %rcx, 0x90(%r14)
testq %rsi, %rsi
je 0x2b8cd
leaq 0x90(%r14), %rdi
callq 0x168f8
movq (%r15), %rax
movq $0x0, (%r15)
movq 0x98(%r14), %rsi
movq %rax, 0x98(%r14)
testq %rsi, %rsi
je 0x2b8f9
addq $0x98, %r14
movq %r14, %rdi
callq 0x168f8
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18f9e
movq 0x30(%r14), %rdi
leaq 0x6c565(%rip), %rax     # 0x99370
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x2ce36
movq 0x6c180(%rip), %rdx     # 0x98fa8
cmpb $0x0, (%rdx)
je 0x2ce32
incl 0x8(%rcx)
jmp 0x2ce36
lock
incl 0x8(%rcx)
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2ce61
movq 0x6c155(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x2ce5d
incl 0x8(%rax)
jmp 0x2ce61
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 0x2ce85
callq 0xdcba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ce94
callq 0xdcba
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d7f0
leaq 0x28(%rsp), %rdi
callq 0x2d0be
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x2cee7
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2ced8
callq 0xdcba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2cee7
callq 0xdcba
leaq 0x28(%rsp), %rdi
callq 0x2d0be
jmp 0x2cef9
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x2cf6b
movq %r14, %rdi
callq 0xa380
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x14d22
movq %r14, %rdi
callq 0xa170
leaq 0x28(%rsp), %rdi
callq 0x20160
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a8b3(%rip), %rsi     # 0x777e7
leaq 0x4a8d5(%rip), %rdx     # 0x77810
movq %rbx, %rdi
callq 0xdf6a
leaq 0x28(%rsp), %rdi
callq 0x148f8
callq 0xa4c0
jmp 0x2ceab
jmp 0x2cf59
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x148f8
callq 0xa4c0
movq %r14, %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcaf
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c3f3(%rip), %rax     # 0x99380
movq (%rax), %rcx
movq 0x40(%rcx), %rax
movq 0x48(%rcx), %r14
testq %r14, %r14
je 0x2cfaf
movq 0x6c004(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x2cfce
incl 0x8(%r14)
jmp 0x2cfd3
movq 0x18(%rax), %rdi
callq 0xa3a0
leaq 0x6c411(%rip), %rcx     # 0x993d0
movq %rax, (%rcx)
leaq 0x6c40f(%rip), %rcx     # 0x993d8
movq %rax, (%rcx)
jmp 0x2cffd
lock
incl 0x8(%r14)
movq 0x18(%rax), %rdi
callq 0xa3a0
leaq 0x6c3ed(%rip), %rcx     # 0x993d0
movq %rax, (%rcx)
leaq 0x6c3eb(%rip), %rcx     # 0x993d8
movq %rax, (%rcx)
testq %r14, %r14
je 0x2cffd
movq %r14, %rdi
callq 0xdcba
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %rdi
callq 0xa350
leaq 0x6c3b6(%rip), %rbx     # 0x993d0
movq (%rbx), %rdi
callq 0xa350
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x6c3aa(%rip), %rcx     # 0x993d8
movq %rax, (%rcx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2d0ae
movq %rbx, %rdi
callq 0xa380
movq %rsp, %rdi
movq %rax, %rsi
callq 0x14d22
movq %rbx, %rdi
callq 0xa170
movq %rsp, %rdi
callq 0x20160
movq 0x6bf45(%rip), %rdi     # 0x98fb0
callq 0xa1a0
movq %rax, %rbx
leaq 0x4a797(%rip), %rsi     # 0x77811
movl $0x30, %edx
movq %rax, %rdi
callq 0xa320
movq %rbx, %rdi
callq 0xa1a0
movq %rsp, %rdi
callq 0x148f8
callq 0xa4c0
jmp 0x2d031
movq %rax, %rbx
movq %rsp, %rdi
callq 0x148f8
callq 0xa4c0
movq %rbx, %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcaf
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: stringToLambda(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
function<void(Action inLeft, Action inRight, CppProgram* prog)> stringToLambda(string cppKode)
{
	if (cppKode.empty())
	{
		return nullptr;
	}
	
	return [=](Action inLeft, Action inRight, CppProgram* prog)
	{
		int start=0;
		int i;
		
		do
		{
			i=searchInString(cppKode, "$", start);
			
			if (i<0)
			{
				prog->code(cppKode.substr(start, cppKode.size()-start));
			}
			else
			{
				prog->code(cppKode.substr(start, i-start));
				
				if (substringMatches(cppKode, i, "$."))
				{
					prog->pushExpr();
						inLeft->addToProg(prog);
						start=i+string("$.").size();
					prog->popExpr();
				}
				else if (substringMatches(cppKode, i, "$:"))
				{
					prog->pushExpr();
						inRight->addToProg(prog);
						start=i+string("$:").size();
					prog->popExpr();
				}
				else if (substringMatches(cppKode, i, "$$"))
				{
					prog->code("$");
					start=i+string("$$").size();
				}
				else
				{
					throw PhplusError("invalid '$' escape in C++ code: "+cppKode, INTERNAL_ERROR);
				}
			}
			
		} while (i>=0);
		
		//if (prog->getExprLevel()==0)
		//	prog->endln();
	};
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x2d6a5
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xdde2
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x20, %edi
callq 0xa2d0
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x2d6b1
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2d6b8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x2d6ed
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, (%rbx)
leaq 0x12364(%rip), %rax     # 0x3fa42
movq %rax, 0x18(%rbx)
leaq 0x126a7(%rip), %rax     # 0x3fd90
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2d70a
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45504(%rip), %rdx     # 0x76a4f
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xdf6a
cmpl $0x0, 0x8(%r14)
jle 0x31676
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movslq %ebp, %rax
movq (%r14), %rcx
movb (%rcx,%rax), %al
cmpb $0x24, %al
jne 0x31601
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x1834e
movq 0x10(%rsp), %rdx
movq %r15, %rdi
xorl %esi, %esi
leaq 0x454af(%rip), %rcx     # 0x76a4f
xorl %r8d, %r8d
callq 0xa470
incl %ebp
cmpl 0x8(%r14), %ebp
jge 0x315e8
movslq %ebp, %rax
movq (%r14), %rcx
movb (%rcx,%rax), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setb %cl
movl %eax, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
setb %r13b
orb %cl, %r13b
je 0x315e3
movsbl %al, %esi
movq %r15, %rdi
callq 0xa290
incl %ebp
testb %r13b, %r13b
jne 0x315aa
cmpq $0x0, 0x10(%rsp)
je 0x31610
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x185d6
jmp 0x31653
movsbl %al, %esi
movq %r15, %rdi
callq 0xa290
incl %ebp
jmp 0x3166c
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
leaq 0x48461(%rip), %rsi     # 0x79a85
leaq 0x4845b(%rip), %rdx     # 0x79a86
callq 0xdf6a
movq 0xa0(%rbx), %rdi
movq %r12, %rsi
callq 0x1834e
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x31653
callq 0xa2b0
movq 0x10(%rsp), %rdx
movq %r15, %rdi
xorl %esi, %esi
leaq 0x453eb(%rip), %rcx     # 0x76a4f
xorl %r8d, %r8d
callq 0xa470
cmpl 0x8(%r14), %ebp
jl 0x3156f
movq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1834e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3169b
callq 0xa2b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x316c9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x316cc
callq 0xa2b0
jmp 0x316cc
jmp 0x316c9
jmp 0x316c9
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x316e0
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x316e8
callq 0x3178a
callq 0x31e55
callq 0x33037
callq 0x36c81
callq 0x3a6ab
callq 0x3b373
callq 0x3b595
callq 0x3b8fc
callq 0x3e240
callq 0x3d6c4
callq 0x3ee17
popq %rax
jmp 0x3f654
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48038(%rip), %rax     # 0x96f88
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 0xe5d0
addq %r14, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x4ee62
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_O1/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 0x4efd8
movq 0x49fde(%rip), %rsi     # 0x98fa8
cmpb $0x0, (%rsi)
je 0x4efd4
incl 0x8(%rdx)
jmp 0x4efd8
lock
incl 0x8(%rdx)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x4f003
movq 0x49fb3(%rip), %rdx     # 0x98fa8
cmpb $0x0, (%rdx)
je 0x4efff
incl 0x8(%rcx)
jmp 0x4f003
lock
incl 0x8(%rcx)
cmpq $0x0, 0x98(%rax)
je 0x4f0d1
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 0x4f03c
callq 0xdcba
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4f04b
callq 0xdcba
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x4f07a
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x4f087
movq 0x49f38(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x4f083
incl 0x8(%rax)
jmp 0x4f087
movq $0x0, (%rbx)
jmp 0x4f0b9
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x25d58
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq %rax, (%rbx)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f0b9
callq 0xdcba
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4f0c8
callq 0xdcba
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
callq 0xa140
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f0e8
callq 0xdcba
movq 0x48(%rsp), %rdi
jmp 0x4f106
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f101
callq 0xdcba
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4f110
callq 0xdcba
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49dc8(%rip), %r13     # 0x99460
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 0x2a3a7(%rip), %rsi     # 0x79a87
leaq 0x2a3a5(%rip), %rdx     # 0x79a8c
leaq 0x38(%rsp), %rdi
callq 0xdf6a
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 0x4f71a
callq 0xdcba
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f729
callq 0xa2b0
movq (%r13), %r15
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2a6d0(%rip), %rsi     # 0x79e0e
leaq 0x2a6ce(%rip), %rdx     # 0x79e13
leaq 0x18(%rsp), %rdi
callq 0xdf6a
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 0x4f777
callq 0xdcba
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f786
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 0x4f7b6
jmp 0x4f7c0
jmp 0x4f7bd
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f7c0
callq 0xa2b0
jmp 0x4f7c0
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49c7e(%rip), %r13     # 0x99460
movq (%r13), %rcx
movq 0x8(%r13), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x4f80e
movq 0x497a8(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x4f80a
incl 0x8(%rax)
jmp 0x4f80e
lock
incl 0x8(%rax)
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a269(%rip), %rsi     # 0x79a87
leaq 0x2a267(%rip), %rdx     # 0x79a8c
leaq 0x50(%rsp), %rdi
callq 0xdf6a
leaq 0x20(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x4f972
movl %eax, %r12d
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x4f853
callq 0xa2b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f862
callq 0xdcba
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 0x4f89e
movq 0x49718(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x4f89a
incl 0x8(%rax)
jmp 0x4f89e
lock
incl 0x8(%rax)
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2a560(%rip), %rsi     # 0x79e0e
leaq 0x2a55e(%rip), %rdx     # 0x79e13
leaq 0x30(%rsp), %rdi
callq 0xdf6a
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x4fbf2
movslq %r12d, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xa270
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f8f1
callq 0xa2b0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f900
callq 0xdcba
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 0x4f93d
callq 0xa2b0
jmp 0x4f93d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
jmp 0x4f960
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x4f95b
callq 0xa2b0
jmp 0x4f95b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f96a
callq 0xdcba
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/SourceFile.cpp
// Function: SourceFile::SourceFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
SourceFile::SourceFile(string filenameIn, bool printOutput)
{
	filename=filenameIn;
	try
	{
		loadFile(filenameIn, contents);
		contents+="\n";
	}
	catch (string err)
	{
		throw PhplusError(err, SOURCE_ERROR);
	}
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rbp
movq %rbp, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
callq 0xa1d0
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0xdde2
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x6e2fc
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x5227d
callq 0xa2b0
leaq 0x24ca4(%rip), %rsi     # 0x76f28
movq %r14, %rdi
callq 0xa560
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x522c6
callq 0xa2b0
jmp 0x522c6
movq %rax, (%rsp)
jmp 0x523bb
movq %rdx, %r15
movq %rax, (%rsp)
cmpl $0x1, %r15d
jne 0x523bb
movq (%rsp), %rdi
callq 0xa380
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0xdde2
movq (%rsp), %rdi
callq 0xa170
movl $0x38, %edi
callq 0xa1b0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xdde2
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %r12b
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x200e4
xorl %r12d, %r12d
leaq 0x442e1(%rip), %rsi     # 0x96638
leaq -0x3da66(%rip), %rdx    # 0x148f8
movq 0x8(%rsp), %rdi
callq 0xa4f0
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x5237b
callq 0xdcba
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x52398
callq 0xa2b0
jmp 0x52398
movq %rax, (%rsp)
movb $0x1, %r12b
testb %r12b, %r12b
je 0x523a7
movq 0x8(%rsp), %rdi
callq 0xa240
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x523b6
callq 0xa2b0
callq 0xa4c0
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x523c8
callq 0xa2b0
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x523d5
callq 0xa2b0
movq (%rsp), %rdi
callq 0xa510
movq %rax, %rdi
callq 0xdcaf
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/SourceFile.cpp
// Function: SourceFile::getDirPath[abi:cxx11]()
string SourceFile::getDirPath()
{
	int i=filename.size();
	
	// this will break on windows
	while (i>=0 && filename[i]!='/')
	{
		i--;
	}
	
	return filename.substr(0, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
js 0x5240a
movq (%rsi), %rcx
movl %eax, %edx
cmpb $0x2f, (%rcx,%rdx)
je 0x5240a
leal -0x1(%rax), %edx
testl %eax, %eax
movl %edx, %eax
jg 0x523f4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movslq %eax, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa2f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::addMember(std::shared_ptr<TypeBase>)
void StackFrame::addMember(Type in)
{
	if (!in->isCreatable())
	{
		throw PhplusError("tried to insert uncreatable type "+in->getString()+" into stack frame", INTERNAL_ERROR);
	}
	
	members.push_back(in);
	frameSize+=in->getSize();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x524f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52c6c
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
addq %rax, 0x18(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
callq *0x8(%rax)
leaq 0x27dbc(%rip), %rsi     # 0x7a2d6
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x1562b
leaq 0x27dc8(%rip), %rsi     # 0x7a2f8
leaq 0x58(%rsp), %rdi
callq 0xa560
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x5255b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x52567
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
movq %rbx, %rdi
movl $0x3, %edx
callq 0x200e4
xorl %ebp, %ebp
leaq 0x44093(%rip), %rsi     # 0x96638
leaq -0x3dcb4(%rip), %rdx    # 0x148f8
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x525c6
callq 0xdcba
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x525dc
callq 0xa2b0
jmp 0x525dc
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x525f7
callq 0xa2b0
jmp 0x525f7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52612
callq 0xa2b0
jmp 0x52612
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5261f
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getLeftInType()
Type StackFrame::getLeftInType()
{
	if (leftInputIndex>=0)
	{
		return members[leftInputIndex];
	}
	else
	{
		return Void;
	}
}

// Assembly:
movq %rdi, %rax
movslq 0x24(%rsi), %rcx
testq %rcx, %rcx
js 0x52a85
movq (%rsi), %rdx
shlq $0x4, %rcx
movq (%rdx,%rcx), %rsi
movq %rsi, (%rax)
movq 0x8(%rdx,%rcx), %rcx
jmp 0x52a96
leaq 0x46974(%rip), %rcx     # 0x99400
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x52ab3
movq 0x46502(%rip), %rdx     # 0x98fa8
cmpb $0x0, (%rdx)
je 0x52aaf
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getRightInType()
Type StackFrame::getRightInType()
{
	if (rightInputIndex>=0)
	{
		return members[rightInputIndex];
	}
	else
	{
		return Void;
	}
}

// Assembly:
movq %rdi, %rax
movslq 0x28(%rsi), %rcx
testq %rcx, %rcx
js 0x52ad5
movq (%rsi), %rdx
shlq $0x4, %rcx
movq (%rdx,%rcx), %rsi
movq %rsi, (%rax)
movq 0x8(%rdx,%rcx), %rcx
jmp 0x52ae6
leaq 0x46924(%rip), %rcx     # 0x99400
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x52b03
movq 0x464b2(%rip), %rdx     # 0x98fa8
cmpb $0x0, (%rdx)
je 0x52aff
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getLeftOffset()
size_t StackFrame::getLeftOffset()
{
	if (leftInputIndex>=0)
	{
		return leftInputOffset;
	}
	else
	{
		error.log("tried to get the left input offset from a stack frame that does not have a left input", INTERNAL_ERROR);
		return 0;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, 0x24(%rdi)
js 0x52b17
movq 0x30(%rdi), %rax
jmp 0x52b78
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2787d(%rip), %rsi     # 0x7a3a4
leaq 0x278cb(%rip), %rdx     # 0x7a3f9
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xdf6a
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x467c8(%rip), %rdi     # 0x99313
movq %rbx, %rsi
movl $0x3, %edx
callq 0x1f926
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x52b67
callq 0xdcba
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x52b76
callq 0xa2b0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x52b92
callq 0xdcba
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x52ba1
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getRightOffset()
size_t StackFrame::getRightOffset()
{
	if (rightInputIndex>=0)
	{
		return rightInputOffset;
	}
	else
	{
		throw PhplusError("tried to get the right input offset from a stack frame that does not have a right input", INTERNAL_ERROR);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, 0x28(%rdi)
js 0x52bc9
movq 0x38(%rdi), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x27814(%rip), %rsi     # 0x7a3fa
leaq 0x27864(%rip), %rdx     # 0x7a451
leaq 0x18(%rsp), %rdi
callq 0xdf6a
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x200e4
xorl %ebp, %ebp
leaq 0x43a1a(%rip), %rsi     # 0x96638
leaq -0x3e32d(%rip), %rdx    # 0x148f8
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x52c3f
callq 0xdcba
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x52c56
callq 0xa2b0
jmp 0x52c56
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x52c63
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
nop