LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: replaceSubstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string replaceSubstring(const string& in, const string& searchFor, const string& replaceWith)
{
	string out;
	int i=0;
	
	while (true)
	{
		int j=searchInString(in, searchFor, i);
		
		if (j<0)
			break;
		else
		{
			out+=in.substr(i, j-i);
			out+=replaceWith;
			i=j+searchFor.size();
		}
	}
	
	out+=in.substr(i, string::npos);
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x41940
movslq %r14d, %rdx
testl %eax, %eax
js 0x41a02
movl %eax, %ebp
subl %edx, %eax
movslq %eax, %rcx
movq %r13, %rdi
movq %r12, %rsi
callq 0xa2d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa540
movq %r13, %rdi
callq 0xa558
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0xa540
addl 0x8(%r15), %ebp
movl %ebp, %r14d
jmp 0x419b3
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r12, %rsi
callq 0xa2d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41a41
jmp 0x41a50
jmp 0x41a50
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x41a53
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: sliceStringBy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void sliceStringBy(const string& in, const string& pattern, vector<string>& out)
{
	int start=0;
	
	if (pattern.size()<1)
		return;
	
	while (start<int(in.size()))
	{
		int end=searchInString(in, pattern, start);
		
		if (end<0)
			end=in.size();
		
		out.push_back(in.substr(start, end-start));
		
		start=end+pattern.size();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x41ad6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movl 0x8(%r15), %r13d
cmpl %r13d, %ebp
jge 0x41ad6
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x41940
testl %eax, %eax
cmovnsl %eax, %r13d
movslq %ebp, %rdx
movl %r13d, %eax
subl %ebp, %eax
movslq %eax, %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa2d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13632
movq %r12, %rdi
callq 0xa558
addl 0x8(%r14), %r13d
movl %r13d, %ebp
jmp 0x41a88
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: indentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string indentString(const string& in, string indent, int level)
{
	string out;
	int start=0;
	
	for (int i=0; i<level; i++)
		out+=indent;
	
	for (int i=0; i<int(in.size()-1); i++)
	{
		if (in[i]=='\n')
		{
			out+=in.substr(start, i-start+1);
			for (int i=0; i<level; i++)
				out+=indent;
			start=i+1;
		}
	}
	
	if (start<=int(in.size()))
		out+=in.substr(start, in.size()-start);
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
testl %ecx, %ecx
cmovgl %ecx, %r12d
movl %r12d, 0x4(%rsp)
subl $0x1, %r12d
jb 0x41b42
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa540
jmp 0x41b2f
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
xorl %eax, %eax
movq (%r14), %rsi
movq 0x8(%r14), %rcx
leal -0x1(%rcx), %edx
movslq %edx, %rdi
incq %r13
leaq -0x1(%r13), %r8
movslq %eax, %rdx
cmpq %rdi, %r8
jge 0x41bb1
cmpb $0xa, -0x1(%rsi,%r13)
jne 0x41b59
movl %r13d, %ecx
subl %eax, %ecx
movslq %ecx, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0xa2d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa540
movq %r12, %rdi
callq 0xa558
movl 0x4(%rsp), %ebp
subl $0x1, %ebp
jb 0x41bac
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa540
jmp 0x41b9a
movl %r13d, %eax
jmp 0x41b4c
cmpl %ecx, %eax
jg 0x41bdc
subq %rdx, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa2d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41bf2
jmp 0x41c05
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x41c08
jmp 0x41c05
jmp 0x41c05
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: tabsToSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
string tabsToSpaces(const string& in, int spaceNum)
{
	int xPos=0;
	string out;
	int sectionStart=0;
	
	for (unsigned i=0; i<in.size(); i++)
	{
		if (substringMatches(in, i, "\t"))
		{
			string tabStr;
			
			for (int j=0; j<spaceNum-(xPos%spaceNum); j++)
			{
				tabStr+=" ";
			}
			
			out+=in.substr(sectionStart, i-sectionStart)+tabStr;
			
			sectionStart=i+1;
		}
		
		xPos++;
		
		if (substringMatches(in, i, "\n"))
		{
			xPos=0;
		}
	}
	
	out+=in.substr(sectionStart, in.size());
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, 0x1c(%rsp)
movq %rsi, %r13
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, 0x10(%rsp)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %r12
leaq 0x12e1b(%rip), %r15     # 0x54a6c
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
xorl %ebp, %ebp
movl %ebp, %eax
movq %r13, %rbx
movq 0x8(%r13), %rcx
movslq 0xc(%rsp), %r13
cmpq %rax, %rcx
jbe 0x41da8
movq %r12, %rdi
leaq 0x12d9a(%rip), %rsi     # 0x54a1e
leaq 0x48(%rsp), %rdx
callq 0xa150
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x41904
movl %eax, %r14d
movq %r12, %rdi
callq 0xa558
testb %r14b, %r14b
je 0x41d54
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
movl 0x8(%rsp), %eax
cltd
movl 0x1c(%rsp), %r14d
idivl %r14d
subl %edx, %r14d
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
subl $0x1, %r14d
jb 0x41cf3
movq %r12, %rdi
movq %r15, %rsi
callq 0xa520
jmp 0x41ce0
movq %rbp, 0x40(%rsp)
movl %ebp, %ecx
subl %r13d, %ecx
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa2d0
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x184b5
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xa540
movq %r14, %rdi
callq 0xa558
movq %rbp, %rdi
callq 0xa558
movq 0x40(%rsp), %rbp
leal 0x1(%rbp), %eax
movl %eax, 0xc(%rsp)
movq %r12, %rdi
callq 0xa558
movq %rbp, %r14
movq %r12, %rdi
leaq 0x13197(%rip), %rsi     # 0x54ef8
leaq 0x48(%rsp), %rdx
callq 0xa150
movl 0x8(%rsp), %ebp
incl %ebp
movq %rbx, %r13
movq %rbx, %rdi
movq %r14, %rbx
movl %ebx, %esi
movq %r12, %rdx
callq 0x41904
movl %eax, %r14d
movq %r12, %rdi
callq 0xa558
testb %r14b, %r14b
movl $0x0, %eax
cmovnel %eax, %ebp
movl %ebp, 0x8(%rsp)
movq %rbx, %rbp
incl %ebp
jmp 0x41c63
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa2d0
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xa540
leaq 0x20(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41e14
jmp 0x41e0f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x41dff
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xa558
jmp 0x41e17
jmp 0x41e14
jmp 0x41e0f
movq %rax, %rbx
jmp 0x41e21
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa558
movq 0x10(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: getTextOfLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
string getTextOfLine(const string& in, int lineNum)
{
	int start=-1;
	int end=-1;
	
	if (lineNum<1)
	{
		return "";
	}
	else if (lineNum==1)
	{
		start=0;
	}
	
	int line=1;
	
	for (unsigned i=0; i<in.size(); i++)
	{
		if (in[i]=='\n')
		{
			if (start<0)
			{
				line++;
				
				if (line==lineNum)
				{
					start=i+1;
				}
			}
			else
			{
				end=i;
				break;
			}
		}
	}
	
	if (start<end)
		return in.substr(start, end-start);
	else if (start>=0)
		return in.substr(start, string::npos);
	else
		return "";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %edx, %edx
jle 0x4230c
xorl %eax, %eax
cmpl $0x1, %edx
setne %al
negl %eax
movq (%rsi), %rdi
movq 0x8(%rsi), %r9
xorl %r8d, %r8d
pushq $0x1
popq %r10
pushq $-0x1
popq %rcx
movl %r8d, %r11d
cmpq %r11, %r9
jbe 0x4231d
cmpb $0xa, (%rdi,%r11)
je 0x422f9
incl %r8d
jmp 0x422e5
testl %eax, %eax
jns 0x4231a
incl %r10d
incl %r8d
cmpl %edx, %r10d
cmovel %r8d, %eax
jmp 0x422e5
leaq 0x1270c(%rip), %rsi     # 0x54a1f
leaq 0xf(%rsp), %rdx
jmp 0x42348
movl %r8d, %ecx
subl %eax, %ecx
jle 0x42329
movslq %eax, %rdx
movslq %ecx, %rcx
jmp 0x42332
testl %eax, %eax
js 0x4233c
movl %eax, %edx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0xa2d0
jmp 0x42350
leaq 0x126dc(%rip), %rsi     # 0x54a1f
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: putStringInBox(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool, int)
string putStringInBox(const string& in, string boxName, bool showLineNums, bool alwaysWidthMax, int maxWidth)
{
	vector<string> lines;
	
	if (maxWidth<0)
	{
		maxWidth=getTermWidth()-4;
	}
	
	sliceStringBy(in, "\n", lines);
	
	tabsToSpaces(lines);
	
	string out=lineListToBoxedString(lines, boxName, showLineNums?1:-1, alwaysWidthMax, maxWidth);
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
testl %r9d, %r9d
jns 0x42e28
callq 0x42ee9
movl %eax, %ebp
addl $-0x4, %ebp
leaq 0x120c9(%rip), %rsi     # 0x54ef8
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x41a63
leaq 0x48(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0x41e33
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xa3b0
movzbl %r15b, %ecx
decl %ecx
orl $0x1, %ecx
movzbl %r14b, %r8d
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %r9d
callq 0x42359
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0x11670
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x42ecb
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x42ed7
jmp 0x42ed4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x11670
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: getTermWidth()
int getTermWidth()
{
	#ifdef __linux__
		// reports inacurate size if the terminal is new, as is the case when running from an IDE
		static bool firstTime=true;
		if (firstTime)
		{
			usleep(20000);
			firstTime=false;
		}
		
		struct winsize w;
		ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
		//cout << "width measured as " << w.ws_col << endl;
		return w.ws_col;
	#else
		return 80;
	#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x3757c(%rip)     # 0x7a471
jne 0x42f08
movl $0x4e20, %edi           # imm = 0x4E20
callq 0xa400
movb $0x1, 0x37569(%rip)     # 0x7a471
pushq $0x1
popq %rdi
leaq 0x8(%rsp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa3f0
movzwl 0x2(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: doubleToString[abi:cxx11](double)
string doubleToString(double in)
{
	long long a=in;
	long long b=(in-a)*10000000000;
	if (b<0)
		b*=-1;
	if (b%10==9)
		b+=1;
	while (b>0 && !(b%10))
		b/=10;
	return to_string(a)+"."+to_string(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
cvttsd2si %xmm0, %rsi
cvtsi2sd %rsi, %xmm1
subsd %xmm1, %xmm0
mulsd 0x15876(%rip), %xmm0    # 0x591b8
movq %rdi, %rbx
cvttsd2si %xmm0, %rax
movq %rax, %rcx
negq %rcx
cmovsq %rax, %rcx
pushq $0xa
popq %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
xorl %eax, %eax
cmpl $0x9, %edx
sete %al
addq %rcx, %rax
movq %rax, %r14
xorl %edx, %edx
divq %rdi
testq %r14, %r14
jle 0x4397c
testq %rdx, %rdx
je 0x4396a
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x3f69b
leaq 0x14294(%rip), %rdx     # 0x57c24
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xc882
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f69b
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1205e
movq %rsp, %rdi
callq 0xa558
leaq 0x20(%rsp), %rdi
callq 0xa558
leaq 0x40(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa558
jmp 0x439f1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa558
jmp 0x43a00
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: stringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int stringToInt(string in)
{
	int out = 0;
	
	for (int i = 0; i < (int)in.size(); i++)
	{
		if (in[i] >= '0' && in[i] <= '9')
		{
			out = out * 10 + in[i] - '0';
		}
		else if (in[i] == '.')
			break;
	}
	
	if (in.size() > 0 && in[0] == '-')
		out *= -1;
	
	return out;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x43a53
movq (%rdi), %r8
movsbl (%r8,%rdx), %r8d
cmpl $0x30, %r8d
jl 0x43a48
cmpb $0x39, %r8b
ja 0x43a4e
imull $0xa, %eax, %eax
addl %r8d, %eax
addl $-0x30, %eax
jmp 0x43a4e
cmpb $0x2e, %r8b
je 0x43a53
incq %rdx
jmp 0x43a24
testq %rcx, %rcx
je 0x43a65
movq (%rdi), %rcx
movl %eax, %edx
negl %edx
cmpb $0x2d, (%rcx)
cmovel %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double stringToDouble(string in)
{
	double out = 0;
	int divider = 1;
	
	for (int i = 0; i < (int)in.size(); i++)
	{
		if (divider == 1)
		{
			if (in[i] >= '0' && in[i] <= '9')
				out = out * 10 + in[i] - '0';
			else if (in[i] == '.')
				divider = 10;
		}
		else
		{
			if (in[i] >= '0' && in[i] <= '9')
			{
				out += (double)(in[i] - '0') / divider;
				divider *= 10;
			}
		}
	}
	
	if (in.size() > 0 && in[0] == '-')
		out *= -1;
	
	return out;
}

// Assembly:
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
pushq $0x1
popq %rsi
xorpd %xmm0, %xmm0
movsd 0x146d3(%rip), %xmm1    # 0x58158
movsd 0x15733(%rip), %xmm2    # 0x591c0
movl %esi, %r8d
cmpq %rcx, %rdx
je 0x43b00
movq (%rdi), %r9
movzbl (%r9,%rcx), %r9d
leal -0x30(%r9), %r10d
cmpl $0x1, %r8d
jne 0x43ac7
cmpb $0x9, %r10b
ja 0x43ae9
movsbl %r9b, %r8d
cvtsi2sd %r8d, %xmm3
mulsd %xmm1, %xmm0
addsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movl %esi, %r8d
jmp 0x43afb
cmpb $0x9, %r10b
ja 0x43afb
addl $-0x30, %r9d
cvtsi2sd %r9d, %xmm3
cvtsi2sd %r8d, %xmm4
divsd %xmm4, %xmm3
addsd %xmm3, %xmm0
imull $0xa, %r8d, %r8d
jmp 0x43afb
xorl %r8d, %r8d
cmpl $0x2e, %r9d
sete %r8b
leal (%r8,%r8,8), %r8d
incl %r8d
incq %rcx
jmp 0x43a90
testq %rax, %rax
je 0x43b15
movq (%rdi), %rax
cmpb $0x2d, (%rax)
jne 0x43b15
xorpd 0x1356b(%rip), %xmm0    # 0x57080
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: loadEntireFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
string loadEntireFile(string inName, bool printOutput)
{
	std::fstream inFile;
	
	if (printOutput)
		cout << "attempting to open '" << inName << "'..." << endl;
	
	inFile.open(inName);
	
	if (!inFile.is_open())
	{
		if (printOutput)
			cout << "'" << inName << "' failed to open :(" << endl;
		return "";
	}
	else
	{
		if (printOutput)
			cout << "file opended, reading file..." << endl;
		
		stringstream strStream;
		strStream << inFile.rdbuf();//read the file
		string out = strStream.str();//str holds the content of the file
		inFile.close();
		
		if (printOutput)
			cout << "file reading done, '" << inName << "' closed" << endl;
		
		return out;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x3a0, %rsp            # imm = 0x3A0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x190(%rsp), %rdi
callq 0xa320
testl %ebp, %ebp
je 0x43b6f
movq 0x3646f(%rip), %rdi     # 0x79fb0
leaq 0x156ab(%rip), %rsi     # 0x591f3
callq 0xa2b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xa290
leaq 0x156a9(%rip), %rsi     # 0x59208
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x190(%rsp), %rdi
pushq $0x18
popq %rdx
movq %r14, %rsi
callq 0xa3a0
leaq 0x210(%rsp), %rdi
callq 0xa0c0
testb %al, %al
je 0x43c33
testb %bpl, %bpl
je 0x43bb7
movq 0x3640d(%rip), %rdi     # 0x79fb0
leaq 0x15677(%rip), %rsi     # 0x59221
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
callq 0xa220
leaq 0x18(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0xa0a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xa480
leaq 0x190(%rsp), %rdi
callq 0xa040
testb %bpl, %bpl
je 0x43c27
movq 0x363b7(%rip), %rdi     # 0x79fb0
leaq 0x1563f(%rip), %rsi     # 0x5923f
callq 0xa2b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xa290
leaq 0x1563d(%rip), %rsi     # 0x59254
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
callq 0xa240
jmp 0x43c81
testb %bpl, %bpl
je 0x43c6d
movq 0x36371(%rip), %rdi     # 0x79fb0
leaq 0x1560c(%rip), %rsi     # 0x59252
callq 0xa2b0
movq %rax, %rdi
movq %r14, %rsi
callq 0xa290
leaq 0x155b0(%rip), %rsi     # 0x5920d
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x10dab(%rip), %rsi     # 0x54a1f
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
leaq 0x190(%rsp), %rdi
callq 0xa0b0
movq %rbx, %rax
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x43cbd
jmp 0x43cbd
movq %rax, %r14
jmp 0x43cb1
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
leaq 0x8(%rsp), %rdi
callq 0xa240
jmp 0x43cc0
movq %rax, %r14
leaq 0x190(%rsp), %rdi
callq 0xa0b0
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: writeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool writeFile(const string& filename, const string& contents, bool debug)
{
	std::ofstream outFile;
	
	if (debug)
		cout << "attempting to write to '" << filename << "'..." << endl;
	
	outFile.open(filename);
	
	if (!outFile.is_open())
	{
		if (debug)
			cout << "'" << filename << "' failed to open :(" << endl;
		return false;
	}
	else
	{
		if (debug)
			cout << "file opended, writing to file..." << endl;
		
		outFile << contents;
		
		outFile.close();
		
		if (debug)
			cout << "file reading done, '" << filename << "' closed" << endl;
		
		return true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa4d0
testl %r14d, %r14d
je 0x43d2f
movq 0x362af(%rip), %rdi     # 0x79fb0
leaq 0x15555(%rip), %rsi     # 0x5925d
callq 0xa2b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa290
leaq 0x154e9(%rip), %rsi     # 0x59208
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
pushq $0x10
popq %rdx
movq %rbx, %rsi
callq 0xa190
leaq 0x78(%rsp), %rdi
callq 0xa0c0
movl %eax, %ebp
testb %al, %al
je 0x43db2
testb %r14b, %r14b
je 0x43d6f
movq 0x36255(%rip), %rdi     # 0x79fb0
leaq 0x15514(%rip), %rsi     # 0x59276
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xa290
leaq 0x8(%rsp), %rdi
callq 0xa420
testb %r14b, %r14b
je 0x43dec
movq 0x3621e(%rip), %rdi     # 0x79fb0
leaq 0x154a6(%rip), %rsi     # 0x5923f
callq 0xa2b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa290
leaq 0x154a4(%rip), %rsi     # 0x59254
jmp 0x43ddc
testb %r14b, %r14b
je 0x43dec
movq 0x361f2(%rip), %rdi     # 0x79fb0
leaq 0x1548d(%rip), %rsi     # 0x59252
callq 0xa2b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa290
leaq 0x15431(%rip), %rsi     # 0x5920d
movq %rax, %rdi
callq 0xa2b0
movq %rax, %rdi
callq 0xa1a0
leaq 0x8(%rsp), %rdi
callq 0xa440
movl %ebp, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa440
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: runCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
string runCmd(string cmd, bool printOutput) // if print output is false, nothing will be printed unil the entire command is done
{
    std::string result = "";
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe) throw std::runtime_error("popen() failed in getOutputFromCmd");
    try {
        while (!feof(pipe)) {
			char c;
            if ((c=getc(pipe)) != EOF)
			{
                result += c;
                
                if (printOutput)
				{
					cout << c;
					cout.flush();
				}
			}
        }
    } catch (...) {
        pclose(pipe);
        throw;
    }
    pclose(pipe);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10952(%rip), %rsi     # 0x54a1f
leaq 0xf(%rsp), %rdx
callq 0xa150
movq (%r14), %rdi
leaq 0x10cdd(%rip), %rsi     # 0x54dbe
callq 0xa110
testq %rax, %rax
je 0x4414e
movq %rax, %r14
movq 0x35ebb(%rip), %r15     # 0x79fb0
movq %r14, %rdi
callq 0xa460
testl %eax, %eax
jne 0x44136
movq %r14, %rdi
callq 0xa100
cmpb $-0x1, %al
je 0x440f5
movsbl %al, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0xa270
testb %bpl, %bpl
je 0x440f5
movq %r15, %rdi
movl %r12d, %esi
callq 0xa310
movq %r15, %rdi
callq 0xa200
jmp 0x440f5
movq %r14, %rdi
callq 0xa410
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xa1b0
movq %rax, %r15
leaq 0x15159(%rip), %rsi     # 0x592b9
movq %rax, %rdi
callq 0xa140
movq 0x35e81(%rip), %rsi     # 0x79ff0
movq 0x35e2a(%rip), %rdx     # 0x79fa0
movq %r15, %rdi
callq 0xa4e0
jmp 0x441a7
movq %rax, %r14
jmp 0x441af
movq %rax, %r14
movq %r15, %rdi
callq 0xa230
jmp 0x441af
movq %rax, %rdi
callq 0xa160
movq %r14, %rdi
callq 0xa410
callq 0xa430
movq %rax, %r14
callq 0xa4b0
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
movq %rax, %rdi
callq 0xc944
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/Action.cpp
// Function: ActionData::ActionData(std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
ActionData::ActionData(Type returnTypeIn, Type inLeftTypeIn, Type inRightTypeIn)
{
	returnType=returnTypeIn;
	inLeftType=inLeftTypeIn;
	inRightType=inRightTypeIn;
	
	if (!returnType || !inLeftType || !inRightType)
	{
		throw PhplusError("ActionData created with null type", INTERNAL_ERROR);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x3497b(%rip), %rax     # 0x790a0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x102ec(%rip), %rsi     # 0x54a1f
leaq 0x7(%rsp), %rdx
movq %rdi, 0x8(%rsp)
callq 0xa150
leaq 0x28(%r14), %rdi
leaq 0x38(%r14), %rbp
leaq 0x48(%r14), %rbx
leaq 0x68(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movq %rax, 0x58(%r14)
andq $0x0, 0x60(%r14)
movb $0x0, 0x68(%r14)
movq %r13, %rsi
callq 0x12ba2
movq %rbp, %rdi
movq %r12, %rsi
callq 0x12ba2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12ba2
cmpq $0x0, 0x28(%r14)
je 0x447b4
cmpq $0x0, 0x38(%r14)
je 0x447b4
cmpq $0x0, 0x48(%r14)
je 0x447b4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r15
leaq 0x14b36(%rip), %rsi     # 0x592fc
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bl
leaq 0x28(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0x19f06
xorl %ebx, %ebx
leaq 0x32d9d(%rip), %rsi     # 0x77598
leaq -0x33170(%rip), %rdx    # 0x11692
movq %r15, %rdi
callq 0xa4e0
movq %rax, %r12
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xa558
testb %bl, %bl
jne 0x4482a
jmp 0x44832
movq %rax, %r12
movq %r15, %rdi
callq 0xa230
leaq 0x58(%r14), %rdi
callq 0xa558
leaq 0x50(%r14), %rdi
callq 0xc984
leaq 0x40(%r14), %rdi
callq 0xc984
addq $0x30, %r14
movq %r14, %rdi
callq 0xc984
movq 0x8(%rsp), %rdi
callq 0xa558
movq %r12, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BoolOpAction.cpp
// Function: AndAction::AndAction(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>)
AndAction(Action firstActionIn, Action secondActionIn)
		:ActionData(Bool, Void, Void)
	{
		firstAction=firstActionIn;
		secondAction=secondActionIn;
		
		if (firstAction->getReturnType()!=Bool)
		{
			throw PhplusError("AndAction created with first action that does not return Bool", INTERNAL_ERROR);
		}
		
		if (secondAction->getReturnType()!=Bool)
		{
			throw PhplusError("AndAction created with second action that does not return Bool", INTERNAL_ERROR);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x34a3d(%rip), %rsi     # 0x7a400
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x12c0a
leaq 0x34a09(%rip), %rbp     # 0x7a3e0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x12c0a
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x12c0a
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x44704
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x33833(%rip), %rax     # 0x79260
movq %rax, (%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r12, %rsi
callq 0x12bbe
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x12bbe
movq 0x78(%rbx), %rax
movq 0x28(%rax), %rax
leaq 0x34993(%rip), %rcx     # 0x7a400
cmpq (%rcx), %rax
jne 0x45a8e
movq (%r13), %rcx
cmpq %rax, 0x28(%rcx)
jne 0x45aed
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r14
leaq 0x13b2d(%rip), %rsi     # 0x595cd
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x31abc(%rip), %rsi     # 0x77598
leaq -0x34451(%rip), %rdx    # 0x11692
movq %r14, %rdi
callq 0xa4e0
jmp 0x45b44
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r14
leaq 0x13b0c(%rip), %rsi     # 0x5960b
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x31a63(%rip), %rsi     # 0x77598
leaq -0x344aa(%rip), %rdx    # 0x11692
movq %r14, %rdi
callq 0xa4e0
movq %rax, %r15
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x68(%rsp), %rdi
jmp 0x45b6f
jmp 0x45b7b
movq %rax, %r15
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x88(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x45b7e
jmp 0x45b86
movq %rax, %r15
movq %r14, %rdi
callq 0xa230
leaq 0x90(%rbx), %rdi
callq 0xc984
leaq 0x80(%rbx), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0x44e86
jmp 0x45bc9
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x38(%rsp), %rdi
callq 0xc984
movq %r15, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BoolOpAction.cpp
// Function: OrAction::OrAction(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>)
OrAction(Action firstActionIn, Action secondActionIn)
		:ActionData(Bool, Void, Void)
	{
		firstAction=firstActionIn;
		secondAction=secondActionIn;
		
		if (firstAction->getReturnType()!=Bool)
		{
			throw PhplusError("OrAction created with first action that does not return Bool", INTERNAL_ERROR);
		}
		
		if (secondAction->getReturnType()!=Bool)
		{
			throw PhplusError("OrAction created with second action that does not return Bool", INTERNAL_ERROR);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3480b(%rip), %rsi     # 0x7a400
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x12c0a
leaq 0x347d7(%rip), %rbp     # 0x7a3e0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x12c0a
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x12c0a
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x44704
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x33659(%rip), %rax     # 0x792b8
movq %rax, (%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r12, %rsi
callq 0x12bbe
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x12bbe
movq 0x78(%rbx), %rax
movq 0x28(%rax), %rax
leaq 0x34761(%rip), %rcx     # 0x7a400
cmpq (%rcx), %rax
jne 0x45cc0
movq (%r13), %rcx
cmpq %rax, 0x28(%rcx)
jne 0x45d1f
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r14
leaq 0x1397d(%rip), %rsi     # 0x5964f
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3188a(%rip), %rsi     # 0x77598
leaq -0x34683(%rip), %rdx    # 0x11692
movq %r14, %rdi
callq 0xa4e0
jmp 0x45d76
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r14
leaq 0x1395b(%rip), %rsi     # 0x5968c
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x31831(%rip), %rsi     # 0x77598
leaq -0x346dc(%rip), %rdx    # 0x11692
movq %r14, %rdi
callq 0xa4e0
movq %rax, %r15
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x68(%rsp), %rdi
jmp 0x45da1
jmp 0x45dad
movq %rax, %r15
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x88(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x45db0
jmp 0x45db8
movq %rax, %r15
movq %r14, %rdi
callq 0xa230
leaq 0x90(%rbx), %rdi
callq 0xc984
leaq 0x80(%rbx), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0x44e86
jmp 0x45dfb
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x38(%rsp), %rdi
callq 0xc984
movq %r15, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BoolOpAction.cpp
// Function: AndAction::execute(void*, void*)
void* execute(void* inLeft, void* inRight)
	{
		bool* out=(bool*)malloc(sizeof(bool));
		*out=false;
		void* firstVal=firstAction->execute(nullptr, nullptr);
		
		if (*((bool*)firstVal))
		{
			void* secondVal=secondAction->execute(nullptr, nullptr);
			
			if (*((bool*)secondVal))
			{
				*out=true;
			}
			
			free(secondVal);
		}
		
		free(firstVal);
		
		return out;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
pushq $0x1
popq %rdi
callq 0xa390
movq %rax, %rbx
movb $0x0, (%rax)
movq 0x78(%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %r14
cmpb $0x1, (%rax)
jne 0x45fbf
movq 0x88(%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
cmpb $0x1, (%rax)
jne 0x45fb7
movb $0x1, (%rbx)
movq %rax, %rdi
callq 0xa330
movq %r14, %rdi
callq 0xa330
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BoolOpAction.cpp
// Function: AndAction::addToProg(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>, CppProgram*)
void addToProg(Action inLeft, Action inRight, CppProgram* prog)
	{
		prog->pushExpr();
			firstAction->addToProg(voidAction, voidAction, prog);
		prog->popExpr();
		
		prog->code(" && ");
		
		prog->pushExpr();
			secondAction->addToProg(voidAction, voidAction, prog);
		prog->popExpr();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %rcx, %rdi
callq 0x3a5fa
movq 0x78(%r14), %r15
leaq 0x34359(%rip), %r12     # 0x7a350
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x12c1e
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x12c1e
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0x3a692
leaq 0x135fe(%rip), %rsi     # 0x5964a
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x39d6c
leaq 0x48(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0x3a5fa
movq 0x88(%r14), %r14
leaq 0x342c8(%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
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0x3a692
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
jmp 0x4611f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x46124
movq %rax, %rbx
jmp 0x46124
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: branchAction(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>, std::shared_ptr<ActionData>)
Action branchAction(Action leftInputIn, Action actionIn, Action rightInputIn)
{
	//return Action(new BranchAction(leftInputIn, actionIn, rightInputIn));
	
	
	if (leftInputIn->getReturnType()->isVoid())
	{
		if (rightInputIn->getReturnType()->isVoid())
		{
			return actionIn;
		}
		else
		{
			return Action(new RightBranchAction(actionIn, rightInputIn));
		}
	}
	else
	{
		if (rightInputIn->getReturnType()->isVoid())
		{
			return Action(new LeftBranchAction(leftInputIn, actionIn));
		}
		else
		{
			return Action(new BranchAction(leftInputIn, actionIn, rightInputIn));
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %bpl, %bpl
je 0x465e1
testb %al, %al
je 0x46648
movups (%r15), %xmm0
andq $0x0, 0x8(%r15)
movups %xmm0, (%rbx)
andq $0x0, (%r15)
jmp 0x46721
testb %al, %al
je 0x466a4
movl $0x98, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x12c1e
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c1e
movb $0x1, %bpl
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x46c80
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48498
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
jmp 0x4671c
movl $0x98, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c1e
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x12c1e
movb $0x1, %bpl
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4679c
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x483fc
leaq 0x60(%rsp), %rdi
callq 0xc984
leaq 0x70(%rsp), %rdi
jmp 0x4671c
movl $0xa8, %edi
callq 0xa2c0
movq %rax, %r14
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x12c1e
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x12c1e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x12c1e
movb $0x1, %r12b
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x47164
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48534
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
testb %r12b, %r12b
jne 0x4678b
jmp 0x46793
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xc984
leaq 0x70(%rsp), %rdi
jmp 0x46781
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xc984
testb %bpl, %bpl
je 0x46793
movq %r14, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: RightBranchAction::getDescription[abi:cxx11]()
string getDescription()
	{
		if (action && rightInput)
		{
			return str::makeRootUpBinaryTree(action->getDescription(), "", rightInput->getReturnType()->getName(), "", rightInput->getDescription());
			//return getReturnType()->toString() + " <- [" + leftInput->getDescription() + "].[" + action->getDescription() + "]:[" + rightInput->getDescription() + "]";
			//return "(" + action->getDescription() + " <- " + rightInput->getDescription() + ")";
			//return getReturnType()->getName() + " <- " + leftInput->getDescription() + "." + action->getDescription() + ":" + rightInput->getDescription();
		}
		else
			return "[branch with null element]";
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %rsi
testq %rsi, %rsi
je 0x47ad9
cmpq $0x0, 0x88(%r14)
je 0x47ad9
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
leaq 0xcff0(%rip), %rsi      # 0x54a1f
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
movq 0x88(%r14), %rax
movq 0x28(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0x3af9c
leaq 0xcfc2(%rip), %rsi      # 0x54a1f
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xa150
movq 0x88(%r14), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %rbx, %rdi
callq 0x5141d
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x48(%rsp), %rdi
callq 0xa558
leaq 0x68(%rsp), %rdi
callq 0xa558
leaq 0x88(%rsp), %rdi
callq 0xa558
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x47aed
leaq 0x11d3a(%rip), %rsi     # 0x5981a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x47b0d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x47b1c
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xa558
jmp 0x47b2b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xa558
jmp 0x47b3d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: RightBranchAction::addToProg(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>, CppProgram*)
void addToProg(Action inLeft, Action inRight, CppProgram* prog)
	{
		Action rightInTmp = rightInput;
		
		if (rightInTmp->getReturnType()!=action->getInRightType())
			rightInTmp=cppTupleCastAction(rightInTmp, action->getInRightType());
		
		action->addToProg(voidAction, rightInTmp, prog);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x88(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12c1e
movq (%r15), %rax
movq 0x78(%r14), %r15
movq 0x28(%rax), %rax
cmpq 0x48(%r15), %rax
je 0x47c2e
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x12c1e
movq 0x78(%r14), %rsi
addq $0x48, %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x12c0a
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4c21a
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x13816
leaq 0x60(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xc984
movq 0x78(%r14), %r15
leaq 0x3271b(%rip), %rsi     # 0x7a350
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x12c1e
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x12c1e
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
callq 0xc984
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
jmp 0x47cb6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: LeftBranchAction::getDescription[abi:cxx11]()
string getDescription()
	{
		if (leftInput && action)
		{
			return str::makeRootUpBinaryTree(action->getDescription(), leftInput->getReturnType()->getName(), "", leftInput->getDescription(), "");
			//return getReturnType()->toString() + " <- [" + leftInput->getDescription() + "].[" + action->getDescription() + "]:[" + rightInput->getDescription() + "]";
			//return "(" + leftInput->getDescription() + " -> " + action->getDescription() + ")";
			//return getReturnType()->getName() + " <- " + leftInput->getDescription() + "." + action->getDescription() + ":" + rightInput->getDescription();
		}
		else
			return "[branch with null element]";
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x78(%rsi)
je 0x47df1
movq %rsi, %r14
movq 0x88(%rsi), %rsi
testq %rsi, %rsi
je 0x47df1
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x78(%r14), %rax
movq 0x28(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x3af9c
leaq 0xccbd(%rip), %rsi      # 0x54a1f
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
movq 0x78(%r14), %rsi
movq (%rsi), %rax
leaq 0x48(%rsp), %rdi
callq *0x18(%rax)
leaq 0xcc98(%rip), %rsi      # 0x54a1f
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xa150
leaq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x48(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %rbx, %rdi
callq 0x5141d
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x48(%rsp), %rdi
callq 0xa558
leaq 0x68(%rsp), %rdi
callq 0xa558
leaq 0x88(%rsp), %rdi
callq 0xa558
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x47e05
leaq 0x11a22(%rip), %rsi     # 0x5981a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x47e25
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x47e34
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xa558
jmp 0x47e43
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xa558
jmp 0x47e55
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: LeftBranchAction::execute(void*, void*)
void* execute(void* inLeft, void* inRight)
	{
		void* leftData=leftInput->execute(nullptr, nullptr);
		void* outData=action->execute(leftData, nullptr);
		free(leftData);
		return outData;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %r14
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
xorl %edx, %edx
callq *0x20(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0xa330
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Actions/BranchAction.cpp
// Function: LeftBranchAction::addToProg(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>, CppProgram*)
void addToProg(Action inLeft, Action inRight, CppProgram* prog)
	{
		Action leftInTmp = leftInput;
		
		if (leftInTmp->getReturnType()!=action->getInLeftType())
			leftInTmp=cppTupleCastAction(leftInTmp, action->getInLeftType());
		
		action->addToProg(leftInTmp, voidAction, prog);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x78(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12c1e
movq (%r15), %rax
movq 0x88(%r14), %r15
movq 0x28(%rax), %rax
cmpq 0x38(%r15), %rax
je 0x47f4c
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x12c1e
movq 0x88(%r14), %rsi
addq $0x38, %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x12c0a
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4c21a
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x13816
leaq 0x60(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xc984
movq 0x88(%r14), %r15
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x12c1e
leaq 0x323eb(%rip), %rsi     # 0x7a350
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x12c1e
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
callq 0xc984
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
jmp 0x47fd4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xc984
leaq 0x10(%rsp), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa500
nop