LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x98, %edi
callq 0xa2c0
movq %rax, %r15
movq %rax, %rdi
callq 0x131b6
movq %r15, (%rbx)
leaq 0x88(%r15), %rdi
movq %r12, %rsi
callq 0x22230
addq $0x90, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12da6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0xa0, %edi
callq 0xa2c0
movq %rax, %r15
movq %rax, %rdi
callq 0x1318e
movq %r15, (%r14)
leaq 0x88(%r15), %rdi
movq %r13, %rsi
callq 0x12da6
leaq 0x90(%r15), %rdi
movq %r12, %rsi
callq 0x12da6
addq $0x98, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12da6
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x14ecc
movq 0x30(%r14), %r14
leaq 0x57549(%rip), %r15     # 0x7a350
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x12c1e
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c1e
movq (%r14), %rax
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x17c72
leaq 0x28(%rsp), %rdi
callq 0x2302e
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x22e9c
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0x2302e
jmp 0x22eae
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x22f17
movq %r14, %rdi
callq 0xa360
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x119b8
movq %r14, %rdi
callq 0xa160
leaq 0x28(%rsp), %rdi
callq 0x19f60
leaq 0x3299e(%rip), %rsi     # 0x55880
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
leaq 0x28(%rsp), %rdi
callq 0x11692
callq 0xa4b0
jmp 0x22e66
jmp 0x22f05
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x11692
callq 0xa4b0
movq %r14, %rdi
callq 0xa500
movq %rax, %rdi
callq 0xc944
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x57425(%rip), %rax     # 0x7a360
movq (%rax), %rsi
addq $0x40, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12e1a
movq (%r14), %rax
movq 0x18(%rax), %rdi
callq 0xa390
leaq 0x5744e(%rip), %r14     # 0x7a3b0
movq %rax, (%r14)
leaq 0x5744c(%rip), %r15     # 0x7a3b8
movq %rax, (%r15)
leaq 0x10(%rsp), %rdi
callq 0xc984
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %rdi
callq 0xa330
movq (%r14), %rdi
callq 0xa330
andq $0x0, (%r14)
andq $0x0, (%r15)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2301e
movq %rbx, %rdi
callq 0xa360
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x119b8
movq %rbx, %rdi
callq 0xa160
leaq 0x8(%rsp), %rdi
callq 0x19f60
movq 0x56fd1(%rip), %rdi     # 0x79fb0
callq 0xa1a0
leaq 0x328bf(%rip), %rsi     # 0x558aa
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
callq 0x11692
callq 0xa4b0
jmp 0x22f9f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11692
callq 0xa4b0
movq %rbx, %rdi
callq 0xa500
movq %rax, %rdi
callq 0xc944
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x8(%rsi)
je 0x233f6
leaq 0x8(%rsp), %rdi
callq 0xa3b0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
pushq $0x20
popq %rdi
callq 0xa2c0
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rax)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x23402
movq %rsi, (%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
jmp 0x23408
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x2343f
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
movq %rcx, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, 0x8(%rax)
movb $0x0, 0x10(%rdi)
movq %rax, (%rbx)
leaq 0xb1d3(%rip), %rax      # 0x2e5fe
movq %rax, 0x18(%rbx)
leaq 0xb516(%rip), %rax      # 0x2e94c
movq %rax, 0x10(%rbx)
callq 0xa558
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x182be
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgPpStr(CppProgram*)
void addToProgPpStr(CppProgram * prog)
{
	if (!prog->hasFunc("$ppStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$ppStr", {{"const char *", "in"}}, strType,
			"int size = 0;\n"
			"while (in[size]) size++;\n"
			//"unsigned char * data = (unsigned char *)malloc(size);\n"
			//"memcpy(data, in, s ize);\n"
			//"return "+strType+"(size, data);\n"
			"return "+strType+"(size, (unsigned char*)in);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x33958(%rip), %rsi     # 0x57090
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xa150
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xb0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x2389d
leaq 0x56cc7(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x338e9(%rip), %rsi     # 0x57090
leaq 0xf0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x338d7(%rip), %rsi     # 0x57097
leaq 0x316b6(%rip), %rdx     # 0x54e7d
leaq 0xb0(%rsp), %rdi
callq 0x39aca
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa3b0
leaq 0x3389d(%rip), %rsi     # 0x570a4
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xc8a1
leaq 0x338b6(%rip), %rdx     # 0x570d3
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc882
leaq 0xf0(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x90(%rsp), %rcx
leaq 0x70(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0x39b5a
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0xa558
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x238bb
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x238ca
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x238dc
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39b5a
jmp 0x238eb
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
jmp 0x23930
movq %rax, %rbx
jmp 0x238f8
movq %rax, %rbx
jmp 0x23905
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x23935
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x23935
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgCStr(CppProgram*)
void addToProgCStr(CppProgram * prog)
{
	if (!prog->hasFunc("$cStr"))
	{
		if (prog->hasFunc("$cStr"))
			return;
		
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$cStr", {{strType, "in"}}, "char *",
			"char * out = (char *)malloc(in._size+1);\n"
			"memcpy(out, in._data, in._size);\n"
			"out[in._size] = 0;\n"
			"return out;\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x33799(%rip), %rsi     # 0x570f0
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x23ad0
leaq 0x33761(%rip), %rsi     # 0x570f0
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x23ad0
leaq 0x56a79(%rip), %rsi     # 0x7a440
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x50(%rsp), %rdi
callq 0xc984
leaq 0x336fb(%rip), %rsi     # 0x570f0
leaq 0xd0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x3146f(%rip), %rdx     # 0x54e7d
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x39b7c
leaq 0x78(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x33662(%rip), %rsi     # 0x5709d
leaq 0xb0(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xa150
leaq 0x336a2(%rip), %rsi     # 0x570f6
leaq 0x90(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa150
leaq 0xd0(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
leaq 0x90(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0xb0(%rsp), %rdi
callq 0xa558
leaq 0x78(%rsp), %rdi
callq 0x39b5a
leaq 0x8(%rsp), %rdi
callq 0x39b0a
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x58(%rsp), %rdi
callq 0xa558
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x23af1
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xa558
jmp 0x23b03
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x39b5a
jmp 0x23b12
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39b0a
jmp 0x23b21
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x58(%rsp), %rdi
jmp 0x23b55
movq %rax, %rbx
jmp 0x23b2e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc984
jmp 0x23b5f
jmp 0x23b4d
jmp 0x23b5c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x23b5f
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgSubStr(CppProgram*)
void addToProgSubStr(CppProgram * prog)
{
	if (!prog->hasFunc("$subStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$subStr", {{strType, "in"}, {"int", "a"}, {"int", "b"}}, strType,
			"int size = b - a;\n"
			"unsigned char * data = (unsigned char *)malloc(size);\n"
			"memcpy(data, in._data + a, size);\n"
			"return "+strType+"(size, data);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x335e2(%rip), %rsi     # 0x57160
leaq 0xd8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xa150
leaq 0xd8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xd8(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x23d32
leaq 0x56881(%rip), %rsi     # 0x7a440
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x33573(%rip), %rsi     # 0x57160
leaq 0xb8(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x31277(%rip), %rdx     # 0x54e7d
leaq 0xd8(%rsp), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x39b7c
leaq 0x118(%rsp), %r15
leaq 0x30fbb(%rip), %rsi     # 0x54be5
leaq 0x3428a(%rip), %rdx     # 0x57ebb
movq %r15, %rdi
callq 0x39bb8
leaq 0x158(%rsp), %r15
leaq 0x30f9d(%rip), %rsi     # 0x54be5
leaq 0x33803(%rip), %rdx     # 0x57452
movq %r15, %rdi
callq 0x39bb8
leaq 0x40(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
pushq $0x3
popq %rdx
leaq 0xe(%rsp), %rcx
callq 0x39b20
leaq 0x98(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa3b0
leaq 0x334de(%rip), %rsi     # 0x57168
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xc8a1
leaq 0x3353a(%rip), %rdx     # 0x571da
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xc882
leaq 0xb8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x98(%rsp), %rcx
leaq 0x78(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x78(%rsp), %rdi
callq 0xa558
leaq 0x58(%rsp), %rdi
callq 0xa558
leaq 0x98(%rsp), %rdi
callq 0xa558
leaq 0x40(%rsp), %rdi
callq 0x39b5a
movl $0x80, %ebx
leaq (%rsp,%rbx), %rdi
addq $0xd8, %rdi
callq 0x39b0a
addq $-0x40, %rbx
cmpq $-0x40, %rbx
jne 0x23d01
leaq 0xb8(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xa558
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xa558
jmp 0x23d52
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xa558
jmp 0x23d61
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xa558
jmp 0x23d73
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x39b5a
jmp 0x23d82
movq %rax, %rbx
movl $0x80, %r14d
leaq (%rsp,%r14), %rdi
addq $0xd8, %rdi
callq 0x39b0a
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x23d88
jmp 0x23dd1
movq %rax, %rbx
jmp 0x23dd1
movq %rax, %rbx
jmp 0x23dde
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xc984
jmp 0x23de8
movq %rax, %rbx
addq $-0x40, %r15
movq %r15, %rdi
callq 0x39b0a
cmpq %r14, %r15
jne 0x23dc0
leaq 0xb8(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
jmp 0x23de3
movq %rax, %rbx
jmp 0x23de8
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgIntToStr(CppProgram*)
void addToProgIntToStr(CppProgram * prog)
{
	if (!prog->hasFunc("$intToStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$intToStr", {{"int", "in"}}, prog->getTypeCode(String),
			"bool neg = in < 0;\n"
			"if (neg) in *= -1;\n"
			"int val = in;\n"
			"int size = 0;\n"
			"while (val)\n"
			"{\n"
			"	size++;\n"
			"	val /= 10;\n"
			"}\n"
			"if (size == 0)\n\tsize = 1;\n"
			"if (neg)\n\tsize++;\n"
			"unsigned char * data = (unsigned char *)malloc(size);\n"
			"val = in;\n"
			"for (int i = 0; i<(neg ? size-1 : size); i++)\n"
			"{\n"
			"	data[size-i-1] = (val % 10) + '0';\n"
			"	val /= 10;\n"
			"}\n"
			"if (neg)\n\tdata[0] = '-';\n"
			"return "+strType+"(size, data);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
leaq 0x333d2(%rip), %rsi     # 0x571e9
leaq 0xc0(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xa150
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xc0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x23fa4
leaq 0x565e8(%rip), %rsi     # 0x7a440
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x33363(%rip), %rsi     # 0x571e9
leaq 0x100(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x30d46(%rip), %rsi     # 0x54be5
leaq 0x30fd7(%rip), %rdx     # 0x54e7d
leaq 0xc0(%rsp), %rdi
callq 0x39bf8
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x5656c(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0xa0(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x332f8(%rip), %rsi     # 0x571f3
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xc8a1
leaq 0x332c9(%rip), %rdx     # 0x571da
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xc882
leaq 0x100(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x80(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x80(%rsp), %rdi
callq 0xa558
leaq 0x60(%rsp), %rdi
callq 0xa558
leaq 0xa0(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0x39b5a
leaq 0xc0(%rsp), %rdi
callq 0x39b0a
leaq 0x100(%rsp), %rdi
callq 0xa558
leaq 0x40(%rsp), %rdi
callq 0xa558
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xa558
jmp 0x23fc5
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xa558
jmp 0x23fd4
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xa558
jmp 0x23fe6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0x39b5a
jmp 0x23fff
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x39b0a
leaq 0x100(%rsp), %rdi
callq 0xa558
leaq 0x40(%rsp), %rdi
jmp 0x24044
movq %rax, %rbx
jmp 0x2400c
movq %rax, %rbx
jmp 0x24019
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc984
jmp 0x24049
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x24049
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgStrToInt(CppProgram*)
void addToProgStrToInt(CppProgram * prog)
{
	if (!prog->hasFunc("$strToInt"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$strToInt", {{strType, "in"}}, "int",
			"int out = 0;\n"
			"for (int i = 0; i < in._size; i++)\n"
			"{\n"
			"	if (in._data[i] >= '0' && in._data[i] <= '9')\n"
			"	{\n"
			"		out = out * 10 + in._data[i] - '0';\n"
			"	}\n"
			"	else if (in._data[i] == '.')\n"
			"		break;\n"
			"}\n"
			"if (in._size > 0 && in._data[0] == '-')\n"
			"	out *= -1;\n"
			"return out;\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x332de(%rip), %rsi     # 0x57349
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xa150
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0x90(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x241ac
leaq 0x56394(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x3326f(%rip), %rsi     # 0x57349
leaq 0xd0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x30d8a(%rip), %rdx     # 0x54e7d
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x39b7c
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x30abf(%rip), %rsi     # 0x54be5
leaq 0x70(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xa150
leaq 0x33217(%rip), %rsi     # 0x57353
leaq 0x50(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa150
leaq 0xd0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0x39b5a
leaq 0x90(%rsp), %rdi
callq 0x39b0a
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x30(%rsp), %rdi
callq 0xa558
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x241ca
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x241d9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x39b5a
jmp 0x241e8
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x39b0a
jmp 0x241fa
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x30(%rsp), %rdi
jmp 0x2422d
movq %rax, %rbx
jmp 0x24207
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x24237
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x24237
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgStrToDub(CppProgram*)
void addToProgStrToDub(CppProgram * prog)
{
	if (!prog->hasFunc("$strToDub"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$strToDub", {{strType, "in"}}, "double",
			"double out = 0;\n"
			"int divider = 1;\n"
			"for (int i = 0; i < in._size; i++)\n"
			"{\n"
			"	if (divider == 1)\n"
			"	{\n"
			"		if (in._data[i] >= '0' && in._data[i] <= '9')\n"
			"			out = out * 10 + in._data[i] - '0';\n"
			"		else if (in._data[i] == '.')\n"
			"			divider = 10;\n"
			"	}\n"
			"	else\n"
			"	{\n"
			"		if (in._data[i] >= '0' && in._data[i] <= '9')\n"
			"		{\n"
			"			out += ((double)(in._data[i] - '0')) / (double)divider;\n"
			"			divider *= 10;\n"
			"		}\n"
			"	}\n"
			"}\n"
			"if (in._size > 0 && in._data[0] == '-')\n"
			"	out *= -1;\n"
			"return out;\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x331f6(%rip), %rsi     # 0x5744a
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xa150
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0x90(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x24395
leaq 0x561ab(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x33187(%rip), %rsi     # 0x5744a
leaq 0xd0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x30ba1(%rip), %rdx     # 0x54e7d
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x39b7c
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x308c9(%rip), %rsi     # 0x54bd8
leaq 0x70(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xa150
leaq 0x3312f(%rip), %rsi     # 0x57454
leaq 0x50(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa150
leaq 0xd0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0x39b5a
leaq 0x90(%rsp), %rdi
callq 0x39b0a
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x30(%rsp), %rdi
callq 0xa558
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x243b3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x243c2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x39b5a
jmp 0x243d1
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x39b0a
jmp 0x243e3
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xa558
leaq 0x30(%rsp), %rdi
jmp 0x24416
movq %rax, %rbx
jmp 0x243f0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x24420
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x24420
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgConcatStr(CppProgram*)
void addToProgConcatStr(CppProgram * prog)
{
	if (!prog->hasFunc("$concatStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$concatStr", {{strType, "a"}, {strType, "b"}}, strType,
			"int newSize = a._size + b._size;\n"
			"unsigned char * newData = (unsigned char *)malloc(newSize);\n"
			"memcpy(newData, a._data, a._size);\n"
			"memcpy(newData + a._size, b._data, b._size);\n"
			"return "+strType+"(newSize, newData);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
leaq 0x331d1(%rip), %rsi     # 0x5760e
leaq 0xd0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xa150
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xd0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x245c9
leaq 0x55fc2(%rip), %rsi     # 0x7a440
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x33162(%rip), %rsi     # 0x5760e
leaq 0xb0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x339f6(%rip), %rdx     # 0x57ebb
leaq 0xd0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x39c38
leaq 0x110(%rsp), %rdi
leaq 0x32f6c(%rip), %rdx     # 0x57452
leaq 0x8(%rsp), %rsi
callq 0x39c38
leaq 0x38(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x90(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa3b0
leaq 0x330f6(%rip), %rsi     # 0x57619
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc8a1
leaq 0x33195(%rip), %rdx     # 0x576ce
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc882
leaq 0xb0(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x90(%rsp), %rcx
leaq 0x70(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0x39b5a
pushq $0x40
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0xd0, %rdi
callq 0x39b0a
addq $-0x40, %rbx
cmpq $-0x40, %rbx
jne 0x24598
leaq 0xb0(%rsp), %rdi
callq 0xa558
leaq 0x8(%rsp), %rdi
callq 0xa558
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x245e7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x245f6
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x24608
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39b5a
jmp 0x24617
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%rsp,%r14), %rdi
addq $0xd0, %rdi
callq 0x39b0a
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x2461b
leaq 0xb0(%rsp), %rdi
callq 0xa558
leaq 0x8(%rsp), %rdi
jmp 0x2467f
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x39b0a
jmp 0x24635
movq %rax, %rbx
jmp 0x24635
movq %rax, %rbx
jmp 0x24642
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc984
jmp 0x24684
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x24684
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgAsciiToStr(CppProgram*)
void addToProgAsciiToStr(CppProgram * prog)
{
	if (!prog->hasFunc("$asciiToStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$asciiToStr", {{"int", "in"}}, strType,
			"unsigned char * data = (unsigned char *)malloc(1);\n"
			"*data = in;\n"
			"return "+strType+"(1, data);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x32bea(%rip), %rsi     # 0x57796
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xa150
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xb0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x24d11
leaq 0x55853(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x32b7b(%rip), %rsi     # 0x57796
leaq 0xf0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x2ffb1(%rip), %rsi     # 0x54be5
leaq 0x30242(%rip), %rdx     # 0x54e7d
leaq 0xb0(%rsp), %rdi
callq 0x39bf8
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa3b0
leaq 0x32b27(%rip), %rsi     # 0x577a2
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xc8a1
leaq 0x32b58(%rip), %rdx     # 0x577e9
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc882
leaq 0xf0(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x90(%rsp), %rcx
leaq 0x70(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0x39b5a
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0xa558
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x24d2f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x24d3e
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x24d50
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39b5a
jmp 0x24d5f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
jmp 0x24da4
movq %rax, %rbx
jmp 0x24d6c
movq %rax, %rbx
jmp 0x24d79
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x24da9
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x24da9
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgEqStr(CppProgram*)
void addToProgEqStr(CppProgram * prog)
{
	if (!prog->hasFunc("$eqStr"))
	{
		string strType=prog->getTypeCode(String);
		
		prog->addFunc("$eqStr", {{strType, "a"}, {strType, "b"}}, "bool",
			"if (a._size != b._size)\n"
			"	return false;\n"
			"for (int i = 0; i < a._size; i++)\n"
			"{\n"
			"	if (a._data[i] != b._data[i])\n"
			"		return false;\n"
			"}\n"
			"return true;\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
leaq 0x32822(%rip), %rsi     # 0x5796e
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xa150
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xb0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x252b6
leaq 0x552b3(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x327b3(%rip), %rsi     # 0x5796e
leaq 0x90(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x32ce7(%rip), %rdx     # 0x57ebb
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x39c38
leaq 0xf0(%rsp), %rdi
leaq 0x3225d(%rip), %rdx     # 0x57452
leaq 0x18(%rsp), %rsi
callq 0x39c38
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x2fa80(%rip), %rsi     # 0x54ca0
leaq 0x70(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xa150
leaq 0x3273f(%rip), %rsi     # 0x57975
leaq 0x50(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa150
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0x39b5a
pushq $0x40
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0xb0, %rdi
callq 0x39b0a
addq $-0x40, %rbx
cmpq $-0x40, %rbx
jne 0x25285
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0xa558
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x252d4
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x252e3
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39b5a
jmp 0x252f2
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%rsp,%r14), %rdi
addq $0xb0, %rdi
callq 0x39b0a
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x252f6
jmp 0x25327
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
jmp 0x25327
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
jmp 0x2535a
movq %rax, %rbx
jmp 0x25334
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x2535f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x2535f
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: addToProgMakeIntArray(CppProgram*)
void addToProgMakeIntArray(CppProgram * prog)
{
	if (!prog->hasFunc("$makeIntArray"))
	{
		string aryType=prog->getTypeCode(IntArray);
		
		prog->addFunc("$makeIntArray", {{"int", "size"}}, aryType,
			"int * data = (int *)malloc(size * sizeof(int));\n"
			"return "+aryType+"(size, data);\n"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x3227a(%rip), %rsi     # 0x57ad6
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xa150
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x17166
movl %eax, %ebp
leaq 0xb0(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x259c1
leaq 0x54ae3(%rip), %rsi     # 0x7a380
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c0a
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e88
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x3220b(%rip), %rsi     # 0x57ad6
leaq 0xf0(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x2f301(%rip), %rsi     # 0x54be5
leaq 0x32232(%rip), %rdx     # 0x57b1d
leaq 0xb0(%rsp), %rdi
callq 0x39d2c
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x39b20
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa3b0
leaq 0x321b9(%rip), %rsi     # 0x57ae4
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xc8a1
leaq 0x31899(%rip), %rdx     # 0x571da
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc882
leaq 0xf0(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x90(%rsp), %rcx
leaq 0x70(%rsp), %r8
movq %rbx, %rdi
callq 0x17186
leaq 0x70(%rsp), %rdi
callq 0xa558
leaq 0x50(%rsp), %rdi
callq 0xa558
leaq 0x90(%rsp), %rdi
callq 0xa558
leaq 0x38(%rsp), %rdi
callq 0x39b5a
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
callq 0xa558
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
jmp 0x259df
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x259ee
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xa558
jmp 0x25a00
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39b5a
jmp 0x25a0f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x39b0a
leaq 0xf0(%rsp), %rdi
callq 0xa558
leaq 0x18(%rsp), %rdi
jmp 0x25a54
movq %rax, %rbx
jmp 0x25a1c
movq %rax, %rbx
jmp 0x25a29
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x25a59
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
movq %rax, %rbx
jmp 0x25a59
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ef9e(%rip), %r15     # 0x54a1f
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa150
xorl %ebp, %ebp
cmpl 0x8(%r14), %ebp
jge 0x25b60
movslq %ebp, %r13
movq (%r14), %rax
movb (%rax,%r13), %al
cmpb $0x24, %al
jne 0x25b00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39d6c
movq %r12, %rdi
movq %r15, %rsi
callq 0xa530
incq %r13
movq %r13, %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jge 0x25b0f
movq (%r14), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x25af0
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jae 0x25b0f
incq %rbp
movsbl %al, %esi
movq %r12, %rdi
callq 0xa270
jmp 0x25acc
movsbl %al, %esi
movq %r12, %rdi
callq 0xa270
incl %ebp
jmp 0x25a98
cmpq $0x0, 0x10(%rsp)
je 0x25b24
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39d78
jmp 0x25b50
leaq 0x28(%rsp), %r13
movq %r13, %rdi
leaq 0x322d4(%rip), %rsi     # 0x57e07
leaq 0x7(%rsp), %rdx
callq 0xa150
movq %rbx, %rdi
movq %r13, %rsi
callq 0x39d6c
movq %r13, %rdi
callq 0xa558
movq %r12, %rdi
movq %r15, %rsi
callq 0xa530
jmp 0x25a98
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x39d6c
leaq 0x8(%rsp), %rdi
callq 0xa558
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25b9b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x25b9e
jmp 0x25b9b
jmp 0x25b9b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: populatePhplusStdLib()
void populatePhplusStdLib()
{
	basicSetup();
	populateBasicTypes();
	populateConstants();
	populateOperators();
	populateConverters();
	populateStdFuncs();
	populateTypeInfoFuncs();
	populateMemManagementFuncs();
	populateStringFuncs();
	populateIntArrayAndFuncs();
	populateArrayFuncs();
	populateNonStdFuncs();
	populateCppInterfaceFuncs();
}

// Assembly:
pushq %rax
callq 0x25bb0
callq 0x25c1d
callq 0x26099
callq 0x26c22
callq 0x28ec1
callq 0x2b3cb
callq 0x2bbae
callq 0x2bd0b
callq 0x2bf0a
callq 0x2d754
callq 0x2d020
callq 0x2de99
popq %rax
jmp 0x2e398
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: void setValInTuple<int>(void*, std::shared_ptr<TypeBase>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
inline void setValInTuple(void* data, Type type, string name, T val)
{
	while (type->getType()==TypeBase::PTR)
	{
		type=type->getSubType();
		data=*(void**)data;
	}
		
	OffsetAndType a=type->getSubType(name);
	
	if (!a.type)
		throw PhplusError("tried to set invalid property '"+name+"' from type "+type->getString(), INTERNAL_ERROR);
	
	*((T*)((char*)data+a.offset))=val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x28(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x5, %eax
jne 0x39e16
movq (%r14), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
callq *0x48(%rax)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x135a2
movq %r13, %rdi
callq 0xc984
movq (%r12), %r12
jmp 0x39de3
movq (%r14), %r13
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xa3b0
movq (%r13), %rax
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq *0x50(%rax)
leaq 0xb8(%rsp), %rdi
callq 0xa558
cmpq $0x0, 0x10(%rsp)
je 0x39e77
leaq 0x18(%rsp), %rdi
movq -0x10(%rdi), %rax
movl %ebx, (%r12,%rax)
callq 0xc984
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x1dfa1(%rip), %rsi     # 0x57e2a
leaq 0x78(%rsp), %rdi
movq %r15, %rdx
callq 0xc8a1
leaq 0x1dfad(%rip), %rdx     # 0x57e4a
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xc882
movq (%r14), %rsi
movq (%rsi), %rax
leaq 0x58(%rsp), %rdi
callq *0x8(%rax)
leaq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x1205e
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x98(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3d69d(%rip), %rsi     # 0x77598
leaq -0x28870(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x98(%rsp), %rdi
callq 0xa558
jmp 0x39f2c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
callq 0xa558
jmp 0x39f3e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xa558
jmp 0x39f50
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x39f64
jmp 0x39f6c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
leaq 0x18(%rsp), %rdi
callq 0xc984
jmp 0x39f88
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0xa8, %edi
callq 0xa2c0
movq %rax, %r14
movq %rax, %rdi
callq 0x3a2ea
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd200
movl $0x88, %eax
addq %rax, %r15
movq %r14, %rdi
addq %rax, %rdi
movq %r15, %rsi
callq 0x3a310
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x88, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x12c0a
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x12c0a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x3a588
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
callq 0xc984
cmpq $0x0, 0x8(%rsp)
je 0x3a4a2
leaq 0x10(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x12c1e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x1df64
leaq 0x18(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, (%rbx)
callq 0x1e016
leaq 0x28(%rsp), %rdi
callq 0xc984
jmp 0x3a4a6
andq $0x0, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0xc984
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x3a4d8
movq %rax, %rbx
leaq 0x48(%rsp), %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
movq %r14, %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r12
leaq 0x3fa7a(%rip), %r13     # 0x7a440
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rdi
callq 0xa390
movq %rax, %rbx
movq 0x8(%r12), %r15
movq %r15, %rdi
callq 0xa390
movq %rax, %r14
movq (%r12), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0xa260
movq (%r13), %r12
leaq 0x1d117(%rip), %rsi     # 0x57b1c
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
movq (%r12), %rax
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r12, %rsi
callq *0x50(%rax)
leaq 0x18(%rsp), %rdi
movq -0x10(%rdi), %rax
movl %r15d, (%rbx,%rax)
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xa558
movq (%r13), %r15
leaq 0x1d468(%rip), %rsi     # 0x57eb7
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
movq (%r15), %rax
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
callq *0x50(%rax)
leaq 0x18(%rsp), %rdi
movq -0x10(%rdi), %rax
movq %r14, (%rbx,%rax)
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x3aab2
jmp 0x3aab9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xa558
jmp 0x3aabc
movq %rax, %rbx
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3f964(%rip), %rsi     # 0x7a440
leaq 0x18(%rsp), %rdi
callq 0x12c0a
leaq 0x20(%rsp), %r15
leaq 0x1d02a(%rip), %rsi     # 0x57b1c
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x18(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
callq 0x3abf7
movl %eax, %r12d
leaq 0x48(%rsp), %rdi
callq 0xa558
leaq 0x20(%rsp), %rdi
callq 0xc984
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0xa390
movq %rax, %r15
leaq 0x3f8ff(%rip), %rsi     # 0x7a440
leaq 0x8(%rsp), %rdi
callq 0x12c0a
leaq 0x1d365(%rip), %rsi     # 0x57eb7
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x3adc8
movslq %r12d, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xa260
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xc984
movb $0x0, (%r15,%r14)
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa150
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x3abce
movq %rax, %rbx
leaq 0x10(%rsp), %r15
jmp 0x3abe7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x3abe7
movq %rax, %rbx
movq %r15, %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500