LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AstNode.cpp
// Function: AstExpression::getString[abi:cxx11]()
string AstExpression::getString()
{
	string leftStr;
	if (!leftIn->isVoid())
	{
		leftStr=leftIn->getString();
	}
	
	string centerStr=center->getString();
	
	string rightStr;
	if (!rightIn->isVoid())
	{
		rightStr=rightIn->getString();
	}
	
	return str::makeRootUpBinaryTree(centerStr, "", "", leftStr, rightStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x88(%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0xfc14
movq 0x88(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0xa370
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xfc14
callq 0xa2b0
movq 0x90(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x98(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0xfc7d
movq 0x98(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
leaq 0x60(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xa370
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfc7d
callq 0xa2b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x67dc2(%rip), %rdx     # 0x77a4f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xdfa8
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x67da7(%rip), %rdx     # 0x77a4f
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq 0xdfa8
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x80(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rbx, %rdi
callq 0x722ed
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0xfce6
callq 0xa2b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xfcf4
callq 0xa2b0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd03
callq 0xa2b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd16
callq 0xa2b0
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xfd28
callq 0xa2b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfd69
jmp 0xfd92
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0xfd57
callq 0xa2b0
jmp 0xfd57
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xfd6c
callq 0xa2b0
jmp 0xfd6c
jmp 0xfd69
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd7b
callq 0xa2b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd95
callq 0xa2b0
jmp 0xfd95
jmp 0xfd92
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xfda7
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AstNode.cpp
// Function: AstConstExpression::getString[abi:cxx11]()
string AstConstExpression::getString()
{
	string centerStr=center->getString();
	
	string rightStr;
	if (!rightIn->isVoid())
	{
		rightStr=rightIn->getString();
	}
	
	return str::makeRootUpBinaryTree(centerStr, "", "const", "", rightStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rsi), %rsi
movq (%rsi), %rax
leaq 0x80(%rsp), %rdi
callq *0x18(%rax)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x90(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x10538
movq 0x90(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
leaq 0x60(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xa370
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x10538
callq 0xa2b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x67507(%rip), %rdx     # 0x77a4f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xdfa8
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x66d3f(%rip), %rsi     # 0x772a3
leaq 0x66d3d(%rip), %rdx     # 0x772a8
leaq 0x40(%rsp), %rdi
callq 0xdfa8
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x674ca(%rip), %rdx     # 0x77a4f
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0xdfa8
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rbx, %rdi
callq 0x722ed
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x105c3
callq 0xa2b0
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x105d2
callq 0xa2b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x105e0
callq 0xa2b0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x105ef
callq 0xa2b0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10605
callq 0xa2b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10658
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x10632
callq 0xa2b0
jmp 0x10632
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x10646
callq 0xa2b0
jmp 0x10646
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1065b
callq 0xa2b0
jmp 0x1065b
jmp 0x10658
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x1066a
callq 0xa2b0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10680
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AstNode.cpp
// Function: AstTuple::resolveAction()
void AstTuple::resolveAction()
{
	vector<Action> actions;
	
	for (int i=0; i<int(nodes.size()); i++)
	{
		nodes[i]->setInput(ns, dynamic, Void, Void);
		actions.push_back(nodes[i]->getAction());
	}
	
	action=makeTupleAction(actions);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x88(%rdi), %rax
movq 0x90(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x141f4
xorl %r14d, %r14d
leaq 0x86341(%rip), %r15     # 0x9a400
leaq 0x10(%rsp), %r13
leaq 0x40(%rsp), %rbp
movq 0x85ed8(%rip), %r12     # 0x99fa8
movq (%rax,%r14,8), %rdi
movq 0x70(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rbx), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x140fb
cmpb $0x0, (%r12)
je 0x140f7
incl 0x8(%rax)
jmp 0x140fb
lock
incl 0x8(%rax)
movb 0x68(%rbx), %al
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x14129
cmpb $0x0, (%r12)
je 0x14138
incl 0x8(%rcx)
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
jmp 0x14151
movq %rdx, (%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x14161
lock
incl 0x8(%rcx)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x14161
cmpb $0x0, (%r12)
je 0x1415d
incl 0x8(%rcx)
jmp 0x14161
lock
incl 0x8(%rcx)
movzbl %al, %edx
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
callq 0x14b4c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14185
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x14194
callq 0xdce4
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x141a3
callq 0xdce4
movq 0x88(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdi
callq 0x14dfa
movq %rbp, %rdi
movq %r13, %rsi
callq 0x17772
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x141d0
callq 0xdce4
incq %r14
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x140d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6a4cc
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x50(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
testq %rdi, %rdi
je 0x14231
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x14231
callq 0xdce4
leaq 0x40(%rsp), %rdi
callq 0x14fd0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14274
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1425e
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1426d
callq 0xdce4
movq 0x38(%rsp), %rdi
jmp 0x14281
movq %rax, %rbx
jmp 0x1428b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1428b
callq 0xdce4
leaq 0x40(%rsp), %rdi
callq 0x14fd0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AstNode.cpp
// Function: AstTupleType::getString[abi:cxx11]()
string AstTupleType::getString()
{
	string out;
	
	out+="AstTupleType{";
	
	for (int i=0; i<int(subTypes.size()); i++)
	{
		auto type=&subTypes[i];
		
		if (type->name)
		{
			out+=type->name->getText()+": ";
		}
		
		out+=type->type->getString();
		
		if (i<int(subTypes.size())-1)
		{
			out+=", ";
		}
	}
	
	out+="}";
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x63061(%rip), %rsi     # 0x77598
callq 0xa560
movq 0x88(%r14), %r13
movq 0x90(%r14), %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x146c6
movl $0x10, %r15d
xorl %r12d, %r12d
movq -0x10(%r13,%r15), %rax
testq %rax, %rax
je 0x14622
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0xde0c
movq %rbp, %rdi
leaq 0x68703(%rip), %rsi     # 0x7cca4
callq 0xa560
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x145cc
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x145d2
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa110
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1460e
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x14622
callq 0xa2b0
movq (%r13,%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
leaq 0x10(%rsp), %r13
callq 0xa110
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x14654
callq 0xa2b0
movq 0x88(%r14), %r13
movq 0x90(%r14), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x146b4
movq %rbx, %rdi
leaq 0x66029(%rip), %rsi     # 0x7a6b5
callq 0xa560
movq 0x88(%r14), %r13
movq 0x90(%r14), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
incq %r12
cltq
addq $0x18, %r15
cmpq %rax, %r12
jl 0x14568
leaq 0x661c8(%rip), %rsi     # 0x7a895
movq %rbx, %rdi
callq 0xa560
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14719
jmp 0x14719
movq %rax, %r14
jmp 0x14706
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14706
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
jne 0x1472a
jmp 0x1472f
jmp 0x14719
movq %rax, %r14
jmp 0x1472f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1472f
callq 0xa2b0
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1473e
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstNodeBase::setInput(std::shared_ptr<NamespaceData>, bool, std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
void setInput(Namespace nsIn, bool dynamicIn, Type left, Type right)
	{
		if (inputHasBeenSet)
		{
			throw PhplusError("tried to set input on an AST node '"+getString()+"' more then once", INTERNAL_ERROR, getToken());
		}
		
		inputHasBeenSet=true;
		
		ns=nsIn;
		dynamic=dynamicIn;
		inLeftType=left;
		inRightType=right;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
cmpb $0x1, 0x80(%rdi)
je 0x14bc5
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movb $0x1, 0x80(%r14)
movq (%rsi), %rax
movq %rax, 0x70(%r14)
leaq 0x78(%r14), %rdi
addq $0x8, %rsi
callq 0xdea2
movb %bpl, 0x68(%r14)
movq (%r15), %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xdea2
movq (%rbx), %rax
movq %rax, 0x38(%r14)
addq $0x40, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xdea2
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq *0x18(%rax)
leaq 0x629bf(%rip), %rsi     # 0x775a6
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x158ca
leaq 0x629cd(%rip), %rsi     # 0x775ca
leaq 0x58(%rsp), %rdi
callq 0xa560
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x14c28
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x14c35
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x829ba(%rip), %rsi     # 0x97638
leaq -0x15f(%rip), %rdx      # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14ca7
callq 0xdce4
jmp 0x14ca7
movq %rax, %r14
movb $0x1, %bpl
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14cbe
callq 0xa2b0
jmp 0x14cbe
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14cd1
callq 0xa2b0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14ce4
callq 0xa2b0
testb %bpl, %bpl
jne 0x14d06
jmp 0x14d0e
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14d06
callq 0xa2b0
jmp 0x14d06
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstNodeBase::getAction()
Action getAction()
	{
		if (!action)
		{
			if (!ns)
			{
				throw PhplusError("tried to get action from AST node when input had not been set", INTERNAL_ERROR, getToken());
			}
			
			resolveAction();
			
			if (!nameHint.empty())
				action->nameHint=nameHint;
		}
		
		return action;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
jne 0x14e3f
cmpq $0x0, 0x70(%r14)
je 0x14e72
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
cmpq $0x0, 0x10(%r14)
movq 0x48(%r14), %rdi
je 0x14e3f
leaq 0x8(%r14), %rsi
addq $0x8, %rdi
callq 0xa1d0
movq 0x48(%r14), %rdi
movq %rdi, (%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x14e64
movq 0x85152(%rip), %rcx     # 0x99fa8
cmpb $0x0, (%rcx)
je 0x14e60
incl 0x8(%rax)
jmp 0x14e64
lock
incl 0x8(%rax)
movq %rbx, %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 0x6277e(%rip), %rsi     # 0x7760d
leaq 0x627b4(%rip), %rdx     # 0x7764a
leaq 0x18(%rsp), %rdi
callq 0xdfa8
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x82767(%rip), %rsi     # 0x97638
leaq -0x3b2(%rip), %rdx      # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14ef2
callq 0xdce4
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14f01
callq 0xa2b0
testb %bpl, %bpl
jne 0x14f1f
jmp 0x14f27
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14f1f
callq 0xa2b0
jmp 0x14f1f
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstList::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstList;
		copyToNode(out, copyCache);
		for (int i=0; i<(int)nodes.size(); i++)
		{
			out->nodes.push_back(nodes[i]->makeCopy(copyCache));
		}
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movl $0xa0, %edi
callq 0xa2d0
movq %rax, %r15
addq $0x18, %rax
movq %rax, 0x8(%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
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 0x81b75(%rip), %rcx     # 0x97658
movq %rcx, (%r15)
movups %xmm0, 0x88(%r15)
movq %rax, 0x98(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x15b79
leaq 0x88(%r15), %r12
xorl %ebx, %ebx
movzbl %bpl, %ebp
leaq 0x8(%rsp), %r13
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x16d06
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x15b59
movq %r13, %rdi
callq 0x16b80
incq %rbx
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x15b2d
movq 0x10(%rsp), %rax
movq %r15, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x15ba7
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstToken::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstToken;
		copyToNode(out, copyCache);
		out->token=token;
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x98, %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 0x81a42(%rip), %rax     # 0x976e0
movq %rax, (%r15)
movups %xmm0, 0x88(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r14), %rax
movq %rax, 0x88(%r15)
movl $0x90, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
callq 0xdea2
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstFuncBody::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstFuncBody;
		copyToNode(out, copyCache);
		out->leftTypeNode=leftTypeNode->makeCopy(copyCache);
		out->rightTypeNode=rightTypeNode->makeCopy(copyCache);
		out->returnTypeNode=returnTypeNode->makeCopy(copyCache);
		out->bodyNode=bodyNode->makeCopy(copyCache);
		out->typesInputSet=typesInputSet;
		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 $0xb0, %edi
callq 0xa2d0
movq %rax, %r15
addq $0x18, %rax
movq %rax, 0x8(%r15)
xorl %r13d, %r13d
movq %r13, 0x10(%r15)
movb %r13b, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
movb %r13b, 0x68(%r15)
movups %xmm0, 0x70(%r15)
movb %r13b, 0x80(%r15)
leaq 0x819ef(%rip), %rax     # 0x97768
movq %rax, (%r15)
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movb %r13b, 0xa8(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq %r13, (%r12)
movq 0x88(%r15), %rsi
movq %rax, 0x88(%r15)
testq %rsi, %rsi
je 0x15ded
leaq 0x88(%r15), %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x15ded
movq %rsp, %rdi
callq 0x16b80
movq 0x90(%r14), %rsi
movq (%rsi), %rax
movzbl %bpl, %ebp
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq $0x0, (%r12)
movq 0x90(%r15), %rsi
movq %rax, 0x90(%r15)
testq %rsi, %rsi
je 0x15e42
leaq 0x90(%r15), %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x15e42
movq %rsp, %rdi
callq 0x16b80
movq 0x98(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq $0x0, (%r12)
movq 0x98(%r15), %rsi
movq %rax, 0x98(%r15)
testq %rsi, %rsi
je 0x15e93
leaq 0x98(%r15), %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x15e93
movq %rsp, %rdi
callq 0x16b80
movq 0xa0(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq $0x0, (%r12)
movq 0xa0(%r15), %rsi
movq %rax, 0xa0(%r15)
testq %rsi, %rsi
je 0x15ee7
movq %r15, %rdi
addq $0xa0, %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x15ee7
movq %rsp, %rdi
callq 0x16b80
movb 0xa8(%r14), %al
movb %al, 0xa8(%r15)
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstFuncBody::canBeWhatev()
bool canBeWhatev()
	{
		setTypesInput();
		
		return
			leftTypeNode->getReturnType()->isWhatev() ||
			rightTypeNode->getReturnType()->isWhatev() ||
			returnTypeNode->getReturnType()->isWhatev();
	
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x1555a
movq 0x88(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x15058
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x15f9a
movq 0x90(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x15058
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x15f8b
movq 0x98(%rbx), %rsi
movq %rsp, %rdi
callq 0x15058
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15f8b
callq 0xdce4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x15f9a
callq 0xdce4
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x15fa9
callq 0xdce4
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15fcd
callq 0xdce4
jmp 0x15fcd
jmp 0x15fca
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x15fe3
callq 0xdce4
jmp 0x15fe3
jmp 0x15fe0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x15ff2
callq 0xdce4
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstExpression::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstExpression;
		copyToNode(out, copyCache);
		out->leftIn=leftIn->makeCopy(copyCache);
		out->center=center->makeCopy(copyCache);
		out->rightIn=rightIn->makeCopy(copyCache);
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0xa0, %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 0x8177f(%rip), %rax     # 0x977f0
movq %rax, (%r14)
movups %xmm0, 0x88(%r14)
movq %r13, 0x98(%r14)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq %r13, (%r12)
movq 0x88(%r14), %rsi
movq %rax, 0x88(%r14)
testq %rsi, %rsi
je 0x160dd
leaq 0x88(%r14), %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x160dd
movq %rsp, %rdi
callq 0x16b80
movq 0x90(%r15), %rsi
movq (%rsi), %rax
movzbl %bpl, %ebp
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r12), %rax
movq $0x0, (%r12)
movq 0x90(%r14), %rsi
movq %rax, 0x90(%r14)
testq %rsi, %rsi
je 0x16132
leaq 0x90(%r14), %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x16132
movq %rsp, %rdi
callq 0x16b80
movq 0x98(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r15), %rax
movq $0x0, (%r15)
movq 0x98(%r14), %rsi
movq %rax, 0x98(%r14)
testq %rsi, %rsi
je 0x16184
movq %r14, %rdi
addq $0x98, %rdi
callq 0x16b80
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x16184
movq %rsp, %rdi
callq 0x16b80
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstConstExpression::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstConstExpression;
		copyToNode(out, copyCache);
		out->center=unique_ptr<AstToken>((AstToken*)center->makeCopy(copyCache).release());;
		out->rightIn=center->makeCopy(copyCache);
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movl $0x98, %edi
callq 0xa2d0
movq %rax, %r14
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %ebx, %ebx
movq %rbx, 0x10(%r14)
movb %bl, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movb %bl, 0x68(%r14)
movups %xmm0, 0x70(%r14)
movb %bl, 0x80(%r14)
leaq 0x81663(%rip), %rax     # 0x97878
movq %rax, (%r14)
leaq 0x88(%r14), %r12
movups %xmm0, 0x88(%r14)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r15), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%r13), %rsi
movq %rbx, (%r13)
movq %r12, %rdi
callq 0x16e7c
movq (%r13), %rsi
testq %rsi, %rsi
je 0x1626e
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq 0x88(%r15), %rsi
movq (%rsi), %rax
movzbl %bpl, %edx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x20(%rax)
movq (%r15), %rax
movq $0x0, (%r15)
movq 0x90(%r14), %rsi
movq %rax, 0x90(%r14)
testq %rsi, %rsi
je 0x162c7
movq %r14, %rdi
addq $0x90, %rdi
callq 0x16b80
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x162c7
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq 0x10(%rsp), %rax
movq %r14, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstOpWithInput::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstOpWithInput;
		copyToNode(out, copyCache);
		out->token=token;
		for (int i=0; i<(int)leftIn.size(); i++)
		{
			out->leftIn.push_back(leftIn[i]->makeCopy(copyCache));
		}
		for (int i=0; i<(int)rightIn.size(); i++)
		{
			out->rightIn.push_back(rightIn[i]->makeCopy(copyCache));
		}
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movl $0xc8, %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 0x81587(%rip), %rax     # 0x97900
movq %rax, (%r15)
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movups %xmm0, 0xa8(%r15)
movups %xmm0, 0xb8(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r14), %rax
movq %rax, 0x88(%r15)
movl $0x90, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
callq 0xdea2
movq 0x98(%r14), %rax
movq 0xa0(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movzbl %bpl, %ebp
testl %ecx, %ecx
jle 0x1643f
leaq 0x98(%r15), %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x16d06
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x1641f
movq %r13, %rdi
callq 0x16b80
incq %rbx
movq 0x98(%r14), %rax
movq 0xa0(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x163f3
movq 0xb0(%r14), %rax
movq 0xb8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x164b2
leaq 0xb0(%r15), %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x16d06
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x16492
movq %r13, %rdi
callq 0x16b80
incq %rbx
movq 0xb0(%r14), %rax
movq 0xb8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x16466
movq 0x10(%rsp), %rax
movq %r15, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x164cb
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x164e2
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstTuple::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstTuple;
		copyToNode(out, copyCache);
		for (int i=0; i<(int)nodes.size(); i++)
		{
			out->nodes.push_back(nodes[i]->makeCopy(copyCache));
		}
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movl $0xa0, %edi
callq 0xa2d0
movq %rax, %r15
addq $0x18, %rax
movq %rax, 0x8(%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
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 0x81407(%rip), %rcx     # 0x97988
movq %rcx, (%r15)
movups %xmm0, 0x88(%r15)
movq %rax, 0x98(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x16617
leaq 0x88(%r15), %r12
xorl %ebx, %ebx
movzbl %bpl, %ebp
leaq 0x8(%rsp), %r13
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x16d06
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x165f7
movq %r13, %rdi
callq 0x16b80
incq %rbx
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x165cb
movq 0x10(%rsp), %rax
movq %r15, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x16645
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstTupleType::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstTupleType;
		copyToNode(out, copyCache);
		for (int i=0; i<(int)subTypes.size(); i++)
		{
			out->subTypes.push_back({subTypes[i].name, unique_ptr<AstType>((AstType*)subTypes[i].type->makeCopy(copyCache).release())});
		}
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
movl $0xa0, %edi
callq 0xa2d0
movq %rax, %rsi
addq $0x18, %rax
movq %rax, 0x8(%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movb %al, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
movb %al, 0x68(%rsi)
movups %xmm0, 0x70(%rsi)
movb %al, 0x80(%rsi)
leaq 0x81217(%rip), %rcx     # 0x97a98
movq %rcx, (%rsi)
movups %xmm0, 0x88(%rsi)
movq %rax, 0x98(%rsi)
movq %r14, %rdi
movq %rsi, 0x28(%rsp)
movl %ebx, %edx
callq 0xe604
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x169ae
movq 0x28(%rsp), %rcx
leaq 0x88(%rcx), %r12
xorl %r13d, %r13d
movzbl %bl, %ebp
leaq 0x8(%rsp), %rbx
xorl %r15d, %r15d
movq (%rax,%r13), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax,%r13), %rcx
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0x16912
movq 0x836ab(%rip), %rdx     # 0x99fa8
cmpb $0x0, (%rdx)
je 0x16907
incl 0x8(%rcx)
jmp 0x16912
lock
incl 0x8(%rcx)
movq 0x88(%r14), %rax
movq 0x10(%rax,%r13), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x16f50
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x16956
leaq 0x20(%rsp), %rdi
callq 0x17188
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1696e
callq 0xdce4
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x16980
movq %rbx, %rdi
callq 0x16b80
incq %r15
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
addq $0x18, %r13
cmpq %rcx, %r15
jl 0x168de
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
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 0x169ff
callq 0xdce4
jmp 0x169ff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x16f20
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x169ff
leaq 0x8(%rsp), %rdi
callq 0x16b80
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/../h/AstNode.h
// Function: AstTypeType::makeCopy(bool)
AstNode makeCopy(bool copyCache)
	{
		auto out=new AstTypeType;
		copyToNode(out, copyCache);
		out->returnType=returnType;
		return AstNode(out);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x98, %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 0x8108a(%rip), %rax     # 0x97b48
movq %rax, (%r15)
movups %xmm0, 0x88(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xe604
movq 0x58(%r14), %rax
movq %rax, 0x58(%r15)
leaq 0x60(%r15), %rdi
addq $0x60, %r14
movq %r14, %rsi
callq 0xdea2
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/CppProgram.cpp
// Function: getValidCppId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string getValidCppId(string in)
{
	string cpp;
	
	if (in.empty())
		in="no_name";
	
	int start=0;
	
	// all this should work with unicode (although it may inject random (but valid) characters into the C++ names)
	do
	{
		int i=start;
		
		for (; i<int(in.size()) && (
				(in[i]>='a' && in[i]<='z') ||
				(in[i]>='A' && in[i]<='Z') ||
				(in[i]>='0' && in[i]<='9') ||
				in[i]=='_'
			); i++) {}
		
		if (i!=start)
		{
			if (in[start]>='0' && in[start]<='9')
				cpp+="_";
			cpp+=in.substr(start, i-start);
		}
		
		start=i+1;
		
	} while (start<int(in.size()));
	
	return cpp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
movq %r15, (%rsp)
jne 0x17905
leaq 0x6004e(%rip), %rcx     # 0x7793d
movl $0x7, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa470
movq 0x8(%r14), %rax
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
cmpl %eax, %ebp
jge 0x1796a
movl %ebp, %ecx
movslq %ebp, %r13
movslq %eax, %rdx
movq (%r14), %rsi
addq %r13, %rsi
subq %r13, %rdx
xorl %r15d, %r15d
movb (%rsi,%r15), %dil
cmpb $0x61, %dil
jl 0x17936
cmpb $0x7b, %dil
jb 0x1795d
jmp 0x1796f
cmpb $0x41, %dil
jl 0x17953
cmpb $0x5b, %dil
setb %r8b
cmpb $0x5f, %dil
sete %dil
orb %r8b, %dil
jne 0x1795d
jmp 0x1796f
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x1796f
incq %r15
cmpq %r15, %rdx
jne 0x17924
movl %eax, %r15d
jmp 0x17972
movl %ebp, %r15d
jmp 0x179d3
addl %ebp, %r15d
cmpl %ecx, %r15d
je 0x179d3
movq (%r14), %rax
movb (%rax,%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x17993
movq %rbx, %rdi
leaq 0x64858(%rip), %rsi     # 0x7c1e6
callq 0xa560
movl %r15d, %eax
subl %ebp, %eax
movslq %eax, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xa2f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xa110
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x179cf
callq 0xa2b0
movq 0x8(%r14), %rax
incl %r15d
movl %r15d, %ebp
cmpl %eax, %r15d
jl 0x1790c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17a11
jmp 0x17a11
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17a14
callq 0xa2b0
jmp 0x17a14
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x17a22
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/CppProgram.cpp
// Function: CppNameContainer::makeChild()
shared_ptr<CppNameContainer> CppNameContainer::makeChild()
{
	auto out=shared_ptr<CppNameContainer>(new CppNameContainer());
	children.push_back(out);
	out->parent=this;
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x88, %edi
callq 0xa2d0
leaq 0x30(%rax), %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
leaq 0x40(%rax), %rcx
movl $0x0, 0x40(%rax)
xorl %edx, %edx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movq %rcx, 0x58(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
movq %rdx, 0x80(%rax)
movq %rax, (%r14)
leaq 0x8(%r14), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1e89a
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1e4b4
movq (%r14), %rax
movq %rbx, 0x68(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x17b8c
callq 0xdce4
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ec04
leaq 0x40(%r15), %rcx
cmpq %rcx, %rax
jne 0x1840a
movq 0x68(%r15), %r15
testq %r15, %r15
jne 0x18399
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x5f63d(%rip), %rsi     # 0x77a08
leaq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0xdc11
leaq 0x5f64c(%rip), %rsi     # 0x77a2b
leaq 0x38(%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 0x18432
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1843e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xde0c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
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 0x203f4
xorl %ebp, %ebp
leaq 0x7f1bc(%rip), %rsi     # 0x97638
leaq -0x395d(%rip), %rdx     # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1849d
callq 0xdce4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x184ab
callq 0xa2b0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x184be
callq 0xa2b0
testb %bpl, %bpl
jne 0x184e0
jmp 0x184e8
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x184e0
callq 0xa2b0
jmp 0x184e0
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x5f530(%rip), %rsi     # 0x77a4e
leaq 0x5f52a(%rip), %rdx     # 0x77a4f
callq 0xdfa8
movb $0x1, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x24(%rbx)
leaq 0x40(%rbx), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movb %al, 0x40(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
leaq 0x70(%rbx), %r12
leaq 0x80(%rbx), %rbp
movq %rbp, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movb %al, 0x80(%rbx)
movw $0x0, 0x90(%rbx)
leaq 0x98(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movq %rax, 0xa8(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0xa1d0
movq %r13, %rdi
movq %r14, %rsi
callq 0x1e4b4
movb $0x1, 0x20(%rbx)
movl 0xc(%rsp), %eax
movb %al, 0x90(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x1e576
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x185e2
callq 0xa2b0
movq 0x50(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x185f2
callq 0xa2b0
movq 0x30(%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x18602
callq 0xa2b0
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x18611
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
cmpl $0x0, 0x28(%rdi)
jg 0x18974
cmpb $0x1, 0x20(%r14)
jne 0x18954
movq 0x58(%r14), %rax
cmpq $0x2, %rax
jb 0x18964
movq 0x50(%r14), %rcx
movzbl -0x2(%rcx,%rax), %eax
cmpl $0x3b, %eax
je 0x18964
cmpl $0x7b, %eax
je 0x18964
cmpl $0x7d, %eax
je 0x18964
leaq 0x50(%r14), %rdi
leaq 0x61d5d(%rip), %rsi     # 0x7a6bc
callq 0xa560
movb $0x1, 0x20(%r14)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5f108(%rip), %rsi     # 0x77a99
leaq 0x5f105(%rip), %rdx     # 0x77a9d
movq %rsp, %rdi
callq 0xdfa8
addq $0x50, %r14
leaq 0x38(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x5ae1f
leaq 0x5f090(%rip), %rsi     # 0x77a50
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x158ca
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x7ec40(%rip), %rsi     # 0x97638
leaq -0x3ed9(%rip), %rdx     # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x18a19
callq 0xdce4
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18a34
callq 0xa2b0
jmp 0x18a34
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18a47
callq 0xa2b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18a55
callq 0xa2b0
testb %bpl, %bpl
jne 0x18a72
jmp 0x18a7a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18a72
callq 0xa2b0
jmp 0x18a72
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
cmpl $0x0, 0x28(%rdi)
jle 0x18ef1
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x625ea(%rip), %rsi     # 0x7b4a1
leaq 0x625e4(%rip), %rdx     # 0x7b4a2
movq %rsp, %rdi
callq 0xdfa8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1861a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18edf
callq 0xa2b0
decl 0x28(%rbx)
movb $0x0, 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5eba2(%rip), %rsi     # 0x77ab0
leaq 0x5ebd5(%rip), %rdx     # 0x77aea
leaq 0x38(%rsp), %rdi
callq 0xdfa8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x7e6f0(%rip), %rsi     # 0x97638
leaq -0x4429(%rip), %rdx     # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x18f69
callq 0xdce4
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x18f78
callq 0xa2b0
testb %bpl, %bpl
jne 0x18f82
jmp 0x18fa2
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
jmp 0x18fa2
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18fa2
callq 0xa2b0
jmp 0x18fa2
movq %rax, %r14
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
cmpl $0x0, 0x28(%rdi)
jg 0x19042
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5ee2f(%rip), %rsi     # 0x77e00
leaq 0x5ee2a(%rip), %rdx     # 0x77e02
movq %rsp, %rdi
callq 0xdfa8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1861a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18ff9
callq 0xa2b0
leaq 0x98(%rbx), %r14
movq 0xa0(%rbx), %rax
movq -0x10(%rax), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x17af0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f3d8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19030
callq 0xdce4
incl 0x24(%rbx)
movb $0x1, 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5ea8c(%rip), %rsi     # 0x77aeb
leaq 0x5eac3(%rip), %rdx     # 0x77b29
leaq 0x38(%rsp), %rdi
callq 0xdfa8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x203f4
xorl %ebp, %ebp
leaq 0x7e59f(%rip), %rsi     # 0x97638
leaq -0x457a(%rip), %rdx     # 0x14b26
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x190ba
callq 0xdce4
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x190c9
callq 0xa2b0
testb %bpl, %bpl
jne 0x190d3
jmp 0x19107
movq %rax, %r14
movq %rbx, %rdi
callq 0xa240
jmp 0x19107
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19107
callq 0xdce4
jmp 0x19107
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19107
callq 0xa2b0
jmp 0x19107
movq %rax, %r14
movq %r14, %rdi
callq 0xa510
nop