LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/PhplusStdLib.cpp
// Function: int getValFromTuple<int>(void*, std::shared_ptr<TypeBase>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline T getValFromTuple(void* data, Type type, string name)
{
	while (type->getType()==TypeBase::PTR)
	{
		type=type->getSubType();
		data=*(void**)data;
	}
	
	OffsetAndType a=type->getSubType(name);
	
	if (!a.type)
		throw PhplusError("tried to get invalid property '"+name+"' from type "+type->getString(), INTERNAL_ERROR);
		
	return *((T*)((char*)data+a.offset));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
leaq 0x20(%rsp), %r13
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x5, %eax
jne 0x3ac4d
movq (%r14), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x48(%rax)
movq %r14, %rdi
movq %r13, %rsi
callq 0x135a2
movq %r12, %rdi
callq 0xc984
movq (%rbx), %rbx
jmp 0x3ac1b
movq (%r14), %r12
leaq 0xb8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xa3b0
movq (%r12), %rax
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x50(%rax)
leaq 0xb8(%rsp), %rdi
callq 0xa558
cmpq $0x0, 0x10(%rsp)
je 0x3acaf
leaq 0x18(%rsp), %rdi
movq -0x10(%rdi), %rax
movl (%rbx,%rax), %ebx
callq 0xc984
movl %ebx, %eax
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 0x1d1a7(%rip), %rsi     # 0x57e68
leaq 0x78(%rsp), %rdi
movq %r15, %rdx
callq 0xc8a1
leaq 0x1d175(%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 0x3c865(%rip), %rsi     # 0x77598
leaq -0x296a8(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xc984
leaq 0x98(%rsp), %rdi
callq 0xa558
jmp 0x3ad64
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
callq 0xa558
jmp 0x3ad76
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xa558
jmp 0x3ad88
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3ad9c
jmp 0x3ada4
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
leaq 0x18(%rsp), %rdi
callq 0xc984
jmp 0x3adc0
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/ResolveLiteral.cpp
// Function: resolveStringLiteral(std::shared_ptr<TokenData>)
Action resolveStringLiteral(Token token)
{
	string text=token->getText();
	
	//this nonesens is required because my lexer is shit and includes the first quote but not the last one
	//instead of hardcoding that in, I figured I'd make it flexable so I don't break everthing when I fix the lexer
	
	while (text.size()>0 && text[0]=='"')
		text=text.substr(1, string::npos);
	
	while (text.size()>0 && text[text.size()-1]=='"')
		text=text.substr(0, text.size()-1);
	
	void* obj=cppStr2PncnStr(text);
	
	return constGetAction(obj, String, "\""+text+"\"", globalNamespace);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa3b0
leaq 0x30(%rsp), %r15
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x3bf44
movq (%rsp), %rax
cmpb $0x22, (%rax)
jne 0x3bf44
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa2d0
movq %r14, %rdi
movq %r15, %rsi
callq 0xa350
movq %r15, %rdi
callq 0xa558
jmp 0x3becf
movq (%rsp), %rax
cmpb $0x22, -0x1(%rax,%rcx)
jne 0x3bf49
decq %rcx
leaq 0x30(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xa2d0
movq %rsp, %r14
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa350
movq %r15, %rdi
callq 0xa558
movq 0x8(%r14), %rcx
testq %rcx, %rcx
jne 0x3bf08
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
callq 0xa3b0
leaq 0x80(%rsp), %rdi
callq 0x3a9af
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0xa558
leaq 0x3e4c3(%rip), %rsi     # 0x7a440
leaq 0x20(%rsp), %rdi
callq 0x12c0a
leaq 0x1bed8(%rip), %rsi     # 0x57e66
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
callq 0xc8a1
leaq 0x1bec4(%rip), %rdx     # 0x57e66
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc882
leaq 0x3e3a8(%rip), %rsi     # 0x7a360
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x12bf6
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r8
callq 0x4e48c
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x60(%rsp), %rdi
callq 0xa558
leaq 0x30(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xc984
movq %rsp, %rdi
callq 0xa558
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xc984
leaq 0x60(%rsp), %rdi
callq 0xa558
jmp 0x3c03d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa558
jmp 0x3c04c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xc984
jmp 0x3c071
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xa558
jmp 0x3c071
jmp 0x3c06e
jmp 0x3c06e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/SourceFile.cpp
// Function: SourceFile::SourceFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
SourceFile::SourceFile(string filenameIn, bool printOutput)
{
	filename=filenameIn;
	try
	{
		loadFile(filenameIn, contents);
		contents+="\n";
	}
	catch (string err)
	{
		throw PhplusError(err, SOURCE_ERROR);
	}
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
callq 0xa1d0
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xa3b0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4f6d0
leaq 0x10(%rsp), %rdi
callq 0xa558
leaq 0x189d5(%rip), %rsi     # 0x54ef8
movq %r14, %rdi
callq 0xa520
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xa558
jmp 0x3c558
movq %rax, %r15
jmp 0x3c604
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0x3c604
movq %r15, %rdi
callq 0xa360
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0xa3b0
movq %r15, %rdi
callq 0xa160
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r12
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xa3b0
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3afdb(%rip), %rsi     # 0x77598
leaq -0x2af32(%rip), %rdx    # 0x11692
movq %r12, %rdi
callq 0xa4e0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3c5ed
jmp 0x3c5f5
movq %rax, %r15
movq %r12, %rdi
callq 0xa230
leaq 0x50(%rsp), %rdi
callq 0xa558
callq 0xa4b0
movq %r14, %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa558
movq %r15, %rdi
callq 0xa500
movq %rax, %rdi
callq 0xc944
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/SourceFile.cpp
// Function: SourceFile::getDirPath[abi:cxx11]()
string SourceFile::getDirPath()
{
	int i=filename.size();
	
	// this will break on windows
	while (i>=0 && filename[i]!='/')
	{
		i--;
	}
	
	return filename.substr(0, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %ecx
movq (%rsi), %rdx
cmpl $-0x1, %ecx
pushq $-0x1
popq %rax
cmovll %ecx, %eax
testl %ecx, %ecx
js 0x3c649
movl %ecx, %edi
cmpb $0x2f, (%rdx,%rdi)
je 0x3c647
decl %ecx
jmp 0x3c637
movl %ecx, %eax
movslq %eax, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa2d0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::addMember(std::shared_ptr<TypeBase>)
void StackFrame::addMember(Type in)
{
	if (!in->isCreatable())
	{
		throw PhplusError("tried to insert uncreatable type "+in->getString()+" into stack frame", INTERNAL_ERROR);
	}
	
	members.push_back(in);
	frameSize+=in->getSize();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x3c708
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cc46
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
addq %rax, 0x18(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *0x8(%rax)
leaq 0x1bb66(%rip), %rsi     # 0x5828e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x11ff8
leaq 0x1bb72(%rip), %rdx     # 0x582b0
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc882
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3ae26(%rip), %rsi     # 0x77598
leaq -0x2b0e7(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x3c7a0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xa558
jmp 0x3c7b2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3c7c6
jmp 0x3c7ce
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getLeftOffset()
size_t StackFrame::getLeftOffset()
{
	if (leftInputIndex>=0)
	{
		return leftInputOffset;
	}
	else
	{
		error.log("tried to get the left input offset from a stack frame that does not have a left input", INTERNAL_ERROR);
		return 0;
	}
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
cmpl $0x0, 0x24(%rdi)
js 0x3cb31
movq 0x30(%rdi), %rax
jmp 0x3cb7d
leaq 0x1b824(%rip), %rsi     # 0x5835c
leaq 0x20(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x3d79f(%rip), %rdi     # 0x7a2fb
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/StackFrame.cpp
// Function: StackFrame::getRightOffset()
size_t StackFrame::getRightOffset()
{
	if (rightInputIndex>=0)
	{
		return rightInputOffset;
	}
	else
	{
		throw PhplusError("tried to get the right input offset from a stack frame that does not have a right input", INTERNAL_ERROR);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x0, 0x28(%rdi)
js 0x3cbbd
movq 0x38(%rdi), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x1b7e3(%rip), %rsi     # 0x583b2
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3a993(%rip), %rsi     # 0x77598
leaq -0x2b57a(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x20(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3cc35
jmp 0x3cc3d
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Token.cpp
// Function: TokenData::typeToString[abi:cxx11](TokenData::Type)
string TokenData::typeToString(TokenData::Type in)
{
	switch (in)
	{
		case WHITESPACE: return "whitespace";
		case LINE_END: return "newline";
		case IDENTIFIER: return "identifier";
		case LITERAL: return "literal";
		case STRING_LITERAL: return "string literal";
		case OPERATOR: return "operator";
		case LINE_COMMENT: return "single line comment";
		case BLOCK_COMMENT: return "block comment";
		case SCOPE: return "scope";
		case UNKNOWN: return "UNKNOWN";
		default: return "ERROR GETTING TOKEN TYPE";
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xb, %esi
ja 0x3d0e6
movl %esi, %eax
leaq 0x1b386(%rip), %rcx     # 0x5840c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b3a6(%rip), %rsi     # 0x5843c
leaq 0xf(%rsp), %rdx
jmp 0x3d12a
leaq 0x1854a(%rip), %rsi     # 0x555f1
leaq 0xd(%rsp), %rdx
jmp 0x3d12a
leaq 0x184f1(%rip), %rsi     # 0x555a6
leaq 0xa(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b384(%rip), %rsi     # 0x58447
leaq 0xe(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b37e(%rip), %rsi     # 0x5844f
leaq 0x9(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b384(%rip), %rsi     # 0x58463
leaq 0x8(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b392(%rip), %rsi     # 0x5847f
leaq 0x5(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b102(%rip), %rsi     # 0x581fd
leaq 0xc(%rsp), %rdx
jmp 0x3d12a
leaq 0x1852d(%rip), %rsi     # 0x55636
leaq 0xb(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b360(%rip), %rsi     # 0x58477
leaq 0x6(%rsp), %rdx
jmp 0x3d12a
leaq 0x1b34c(%rip), %rsi     # 0x58471
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Token.cpp
// Function: TokenData::getTypeDescription[abi:cxx11]()
string TokenData::getTypeDescription()
{
	string out;
	
	if (tokenType==TokenData::OPERATOR)
	{
		if (op)
		{
			out+=op->getText()+" ";
		}
		else
		{
			out+="unknown ";
		}
	}
	
	out+=TokenData::typeToString(tokenType);
	
	return out;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
cmpl $0x5, 0x38(%rsi)
jne 0x3d3e2
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x3d3d3
leaq 0x28(%rsp), %rdi
callq 0xa3b0
leaq 0x176cb(%rip), %rdx     # 0x54a6c
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc882
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x3d3e2
leaq 0x1b0c1(%rip), %rsi     # 0x5849b
movq %rbx, %rdi
callq 0xa520
movl 0x38(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x3d070
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa540
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x3d43e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x3d426
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x3d437
jmp 0x3d43e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x3d441
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Token.cpp
// Function: stringFromTokens[abi:cxx11](std::vector<std::shared_ptr<TokenData>, std::allocator<std::shared_ptr<TokenData>>> const&, int, int)
string stringFromTokens(const vector<Token>& tokens, int left, int right)
{
	string out;
	
	for (int i=left; i<=right; ++i)
	{
		out+=tokens[i]->getText();
		if (i<right)
			out+=" ";
	}
	
	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 %rsi, %r14
movb $0x0, 0x10(%rdi)
movslq %edx, %r13
movslq %ecx, %rbp
movq %r13, %r12
shlq $0x4, %r12
leaq 0x8(%rsp), %r15
cmpq %rbp, %r13
jg 0x3d8dd
movq (%r14), %rax
movq (%rax,%r12), %rsi
movq %r15, %rdi
callq 0xa3b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa540
movq %r15, %rdi
callq 0xa558
cmpq %rbp, %r13
jge 0x3d8d4
movq %rbx, %rdi
leaq 0x1719d(%rip), %rsi     # 0x54a6c
callq 0xa520
incq %r13
addq $0x10, %r12
jmp 0x3d899
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d8f1
movq %rax, %r14
jmp 0x3d903
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/../h/Token.h
// Function: TokenData::TokenData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<SourceFile>, int, int, TokenData::Type, std::shared_ptr<OperatorData>)
TokenData(string textIn, shared_ptr<SourceFile> fileIn, int lineIn, int charPosIn, Type tokenTypeIn, Operator opIn=Operator(nullptr))
	{
		text=textIn;
		file=fileIn;
		line=lineIn;
		charPos=charPosIn;
		tokenType=tokenTypeIn;
		op=opIn;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, %r13
movq %rdi, %rbx
movq 0x40(%rsp), %r12
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x40(%rdi)
callq 0xa1d0
leaq 0x20(%rbx), %rdi
leaq 0x40(%rbx), %rbp
movq %r13, %rsi
callq 0x3da16
movl %r15d, 0x30(%rbx)
movl %r14d, 0x34(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x38(%rbx)
movq %rbp, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcabe
movq %rax, %r14
leaq 0x48(%rbx), %rdi
callq 0xc984
leaq 0x28(%rbx), %rdi
callq 0xc984
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/../h/utils/stringUtils.h
// Function: str::subMatches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool subMatches(const string& in, int posBytes, const string& sub)
{
	if (posBytes<0  || sub.size()+posBytes>in.size())
		return false;
	
	for (int i=0; i<(int)sub.size(); i++)
	{
		if (in[i+posBytes]!=sub[i])
			return false;
	}
	
	return true;
}

// Assembly:
testl %esi, %esi
js 0x3da0b
movq 0x8(%rdx), %r8
movl %esi, %ecx
leaq (%r8,%rcx), %rsi
xorl %eax, %eax
cmpq 0x8(%rdi), %rsi
ja 0x3da0d
movq (%rdx), %rsi
movslq %r8d, %rdx
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
addq (%rdi), %rcx
cmpq %rax, %r8
je 0x3da0e
movb (%rcx,%rax), %dil
leaq 0x1(%rax), %r9
cmpb (%rsi,%rax), %dil
movq %r9, %rax
je 0x3d9f5
xorl %eax, %eax
retq
cmpq %rdx, %rax
setge %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TypeBase::getString[abi:cxx11](TypeBase::PrimitiveType)
string TypeBase::getString(PrimitiveType in)
{
	switch (in)
	{
		case UNKNOWN: return "UNKNOWN_TYPE";
		case VOID: return "VOID";
		case BOOL: return "BOOL";
		case BYTE: return "BYTE";
		case INT: return "INT";
		case DUB: return "DUB";
		case TUPLE: return "TUPLE";
		case METATYPE: return "METATYPE";
		default: return "ERROR_GETTING_TYPE";
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x9, %esi
ja 0x3ddcd
movl %esi, %eax
leaq 0x1a732(%rip), %rcx     # 0x584e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1a7dd(%rip), %rsi     # 0x585a3
leaq 0xf(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a802(%rip), %rsi     # 0x585d6
leaq 0x7(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a7d3(%rip), %rsi     # 0x585b5
leaq 0xd(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a7c0(%rip), %rsi     # 0x585b0
leaq 0xe(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a7c9(%rip), %rsi     # 0x585c7
leaq 0x9(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a7c1(%rip), %rsi     # 0x585cd
leaq 0x8(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a7a0(%rip), %rsi     # 0x585ba
leaq 0xc(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a79b(%rip), %rsi     # 0x585c3
leaq 0xa(%rsp), %rdx
jmp 0x3de3b
leaq 0x1a789(%rip), %rsi     # 0x585bf
leaq 0xb(%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/Type.cpp
// Function: TypeBase::matches(std::shared_ptr<TypeBase>)
bool TypeBase::matches(Type other)
{
	if (other==shared_from_this())
		return true;
	
	if (getType()==WHATEV || other->getType()==WHATEV)
		return true;
		
	if (getType()==TUPLE)
	{
		auto subTypes=getAllSubTypes();
		
		if (subTypes->size()==1)
		{
			if ((*subTypes)[0].type->matches(other))
				return true;
		}
	}
	
	if (other->getType()==TUPLE)
	{
		auto subTypes=other->getAllSubTypes();
		
		if (subTypes->size()==1)
		{
			if ((*subTypes)[0].type->matches(shared_from_this()))
				return true;
		}
	}
	
	if (other->getType()!=getType())
		return false;
	
	return matchesSameTypeType(other);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4007c
movq (%r14), %r13
movq (%r12), %r12
leaq 0x40(%rsp), %rdi
callq 0xc984
movb $0x1, %bpl
cmpq %r12, %r13
je 0x3dfb2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
cmpl $0x8, %eax
je 0x3dfb2
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x8, %eax
je 0x3dfb2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
cmpl $0x7, %eax
jne 0x3df11
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cmpq $0x30, %rax
jne 0x3df11
movq 0x20(%rcx), %r13
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x12c0a
movq %r13, %rdi
movq %r12, %rsi
callq 0x3de4c
movl %eax, %r13d
leaq 0x30(%rsp), %rdi
callq 0xc984
testb %r13b, %r13b
jne 0x3dfb2
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x7, %eax
jne 0x3df69
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cmpq $0x30, %rax
jne 0x3df69
movq 0x20(%rcx), %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4007c
movq %r12, %rdi
movq %r13, %rsi
callq 0x3de4c
movl %eax, %r15d
leaq 0x20(%rsp), %rdi
callq 0xc984
testb %r15b, %r15b
jne 0x3dfb2
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
cmpl %eax, %ebp
jne 0x3dfb0
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12c0a
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x60(%rax)
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0xc984
jmp 0x3dfb2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
jmp 0x3dfd4
leaq 0x30(%rsp), %rdi
jmp 0x3dfd4
movq %r12, %rdi
movq %rax, %rbx
callq 0xc984
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TypeBase::actuallyIs(std::shared_ptr<TypeBase>)
Type TypeBase::actuallyIs(Type target)
{
	if (!matches(target))
	{
		throw PhplusError("actuallyIs called with type that doesn't match", INTERNAL_ERROR);
	}
	
	if (isWhatev())
	{
		throw PhplusError("actuallyIs not implemented properly for Whatev type", INTERNAL_ERROR);
	}
	
	return shared_from_this();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x12c0a
movq %r14, %rdi
movq %r15, %rsi
callq 0x3de4c
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0xc984
testb %bpl, %bpl
je 0x3e050
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x3e0a9
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4007c
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x1a587(%rip), %rsi     # 0x585e9
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x39500(%rip), %rsi     # 0x77598
leaq -0x2ca0d(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
jmp 0x3e100
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
leaq 0x1a55d(%rip), %rsi     # 0x58618
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x394a7(%rip), %rsi     # 0x77598
leaq -0x2ca66(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x48(%rsp), %rdi
jmp 0x3e128
jmp 0x3e134
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xc984
leaq 0x68(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3e137
jmp 0x3e14e
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
jmp 0x3e14e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xc984
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleTypeMaker::add(std::shared_ptr<TypeBase>)
void TupleTypeMaker::add(Type type)
{
	string name=getUniqueName();
	
	if (!name.empty())
	{
		add(name, type);
	}
	else
	{
		error.log("finding unique name in tuple type failed", INTERNAL_ERROR);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e476
cmpq $0x0, 0x8(%r15)
je 0x3e3d1
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xa3b0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12c0a
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3e26e
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
jmp 0x3e415
leaq 0x1a29b(%rip), %rsi     # 0x58673
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x3bf02(%rip), %rdi     # 0x7a2fb
leaq 0x30(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xa558
leaq 0x70(%rsp), %rdi
callq 0xa558
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
jmp 0x3e459
jmp 0x3e460
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x3e463
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleTypeMaker::getUniqueName[abi:cxx11]()
string TupleTypeMaker::getUniqueName()
{
	for (char c='a'; c<='z'; ++c)
	{
		string str;
		str+=c;
		bool valid=true;
		
		for (auto i: *subTypes)
		{
			if (i.name==str)
			{
				valid=false;
				break;
			}
		}
		
		if (valid)
			return str;
	}
	
	error.log("you've gotta be fuckin kidding", SOURCE_ERROR);
	return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movb $0x61, %cl
leaq 0x48(%rsp), %r15
movq %rsi, 0x8(%rsp)
movq %rax, (%rsp)
cmpb $0x7b, %cl
je 0x3e512
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl %ecx, %r14d
movsbl %cl, %esi
movq %rbx, %rdi
callq 0xa270
movq (%r12), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x3e56e
movq %r15, %rdi
movq %r12, %rsi
callq 0x1848c
movq %r15, %rdi
movq %rbx, %rsi
callq 0xcdda
movl %eax, %ebp
movq %r15, %rdi
callq 0x12f68
addq $0x30, %r12
testb %bpl, %bpl
je 0x3e4c8
movq %rbx, %rdi
callq 0xa558
movl %r14d, %ecx
incb %cl
movq 0x8(%rsp), %r12
movq (%rsp), %rax
jmp 0x3e49e
leaq 0x1a183(%rip), %rsi     # 0x5869c
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xa150
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x3bdc1(%rip), %rdi     # 0x7a2fb
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xa558
leaq 0x164be(%rip), %rsi     # 0x54a1f
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
jmp 0x3e5a1
movq %rax, %r14
jmp 0x3e5a6
jmp 0x3e59b
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleTypeMaker::get(bool)
Type TupleTypeMaker::get(bool isAnonymous)
{
	if (subTypes)
		return Type(new TupleType(std::move(subTypes), isAnonymous));
	else
		error.log(FUNC+"called after type has been created", INTERNAL_ERROR);
	
	return Void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x3e60a
movl %edx, %ebp
movq %rsi, %r15
pushq $0x58
popq %rdi
callq 0xa2c0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
andq $0x0, (%r15)
movb $0x1, %r15b
movzbl %bpl, %edx
movq %rax, %rdi
callq 0x3e818
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40734
leaq 0x8(%rsp), %rdi
callq 0x12ede
jmp 0x3e682
leaq 0x19752(%rip), %rsi     # 0x57d63
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa150
leaq 0x1a029(%rip), %rdx     # 0x58650
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc882
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x3bcb3(%rip), %rdi     # 0x7a2fb
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xa558
leaq 0x20(%rsp), %rdi
callq 0xa558
leaq 0x3bd66(%rip), %rsi     # 0x7a3e0
movq %rbx, %rdi
callq 0x12c0a
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x40(%rsp), %rdi
callq 0xa558
jmp 0x3e6ae
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa558
jmp 0x3e6d9
movq %rax, %rbx
jmp 0x3e6d9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x12ede
testb %r15b, %r15b
je 0x3e6d9
movq %r14, %rdi
callq 0xa2a0
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleType::TupleType(std::unique_ptr<std::vector<NamedType, std::allocator<NamedType>>, std::default_delete<std::vector<NamedType, std::allocator<NamedType>>>>, bool)
TupleType(unique_ptr<vector<NamedType>> in, bool isAnonymousIn)
	{
		if (in==nullptr)
			error.log(FUNC+" sent null input, compiler will likely shit itself in the near future", INTERNAL_ERROR);
		
		subTypes=std::move(in);
		
		for (auto i: *subTypes)
		{
			if (i.type->isWhatev())
			{
				hasWhatev=true;
			}
			
			if (!i.type->isCreatable())
			{
				hasOnlyCreatable=false;
			}
		}
		
		isAnonymous=isAnonymousIn;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3e9b6
leaq 0x3a5a6(%rip), %rax     # 0x78de0
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
andq $0x0, 0x48(%rbx)
movw $0x1, 0x50(%rbx)
movb $0x1, 0x52(%rbx)
cmpq $0x0, (%r15)
jne 0x3e8bf
leaq 0x1a01e(%rip), %rsi     # 0x5887b
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa150
leaq 0x1a012(%rip), %rdx     # 0x58885
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc882
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x3ba67(%rip), %rdi     # 0x7a2fb
leaq 0x58(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x19a6e
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xa558
movq %r14, %rdi
movq %r15, %rsi
callq 0x40050
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
leaq 0x28(%rsp), %r12
cmpq %r13, %r15
je 0x3e91d
movq %r12, %rdi
movq %r15, %rsi
callq 0x1848c
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x3e8fc
movb $0x1, 0x51(%rbx)
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x3e90f
movb $0x0, 0x52(%rbx)
movq %r12, %rdi
callq 0x12f68
addq $0x30, %r15
jmp 0x3e8d9
movb %bpl, 0x50(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xa558
jmp 0x3e94c
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x3e96c
jmp 0x3e95a
movq %rax, %r15
jmp 0x3e96c
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x12f68
movq %r14, %rdi
callq 0x12ede
movq %rbx, %rdi
callq 0x4043e
movq %r15, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: PrimType::getCompactString[abi:cxx11]()
string getCompactString()
	{
		switch (primType)
		{
			case BOOL: return "b";
			case BYTE: return "y";
			case INT: return "i";
			case DUB: return "d";
			
			default:
				throw PhplusError("tried to make " + getString() + " compact", INTERNAL_ERROR);
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movl 0x48(%rsi), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x3eb66
movq %rdi, %rbx
leaq 0x19a24(%rip), %rcx     # 0x58548
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18fae(%rip), %rsi     # 0x57ae2
jmp 0x3eb4f
leaq 0x1a5e6(%rip), %rsi     # 0x59123
jmp 0x3eb4f
leaq 0x1890c(%rip), %rsi     # 0x57452
jmp 0x3eb4f
leaq 0x19253(%rip), %rsi     # 0x57da2
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xa150
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x19b5e(%rip), %rsi     # 0x586e4
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x11ff8
leaq 0x19b59(%rip), %rdx     # 0x586f3
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0xc882
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x389ca(%rip), %rsi     # 0x77598
leaq -0x2d543(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x50(%rsp), %rdi
callq 0xa558
jmp 0x3ebfc
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xa558
jmp 0x3ec0c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3ec20
jmp 0x3ec28
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: PrimType::getCppLiteral[abi:cxx11](void*, CppProgram*)
string getCppLiteral(void * data, CppProgram * prog)
	{
		string val;
		
		switch (primType)
		{
			case BOOL: val=(*(bool*)data)?"true":"false"; break;
			case BYTE: val=to_string(*(unsigned char*)data); break;
			case INT: val=to_string(*(int*)data); break;
			case DUB: val=doubleToString(*(double*)data); break;
			/*{
				std::ostringstream ss;
				ss << *(double*)data;
				val=ss.str();
			}
			break;*/
			
			default:
				throw PhplusError("tried to convert " + getString() + " to C++ code", INTERNAL_ERROR);
		}
		
		return val;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x48(%rsi), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x3ecd3
leaq 0x198fa(%rip), %rcx     # 0x5855c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl (%rdx), %esi
movq %rsp, %rdi
callq 0x1837a
jmp 0x3ecaf
movl (%rdx), %esi
movq %rsp, %rdi
callq 0x1837a
jmp 0x3ecaf
leaq 0x160b8(%rip), %rax     # 0x54d43
leaq 0x16039(%rip), %rsi     # 0x54ccb
cmpb $0x0, (%rdx)
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xa530
jmp 0x3ecc5
movsd (%rdx), %xmm0
movq %rsp, %rdi
callq 0x43923
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa350
movq %r14, %rdi
callq 0xa558
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %r14
movq (%r15), %rax
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq 0x19a09(%rip), %rsi     # 0x586fc
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
callq 0x11ff8
leaq 0x19a07(%rip), %rdx     # 0x5870e
leaq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0xc882
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x58(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x3885d(%rip), %rsi     # 0x77598
leaq -0x2d6b0(%rip), %rdx    # 0x11692
movq %r14, %rdi
callq 0xa4e0
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x58(%rsp), %rdi
callq 0xa558
jmp 0x3ed69
movq %rax, %r15
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xa558
jmp 0x3ed79
movq %rax, %r15
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3ed8d
jmp 0x3eda0
movq %rax, %r15
movq %r14, %rdi
callq 0xa230
jmp 0x3eda0
jmp 0x3ed9d
jmp 0x3ed9d
jmp 0x3ed9d
movq %rax, %r15
movq %rbx, %rdi
callq 0xa558
movq %r15, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: PrimType::getSize()
size_t getSize()
	{
		switch (primType)
		{
			case BOOL: return sizeof(bool);
			case BYTE: return sizeof(unsigned char);
			case INT: return sizeof(int);
			case DUB: return sizeof(double);
			
			default:
				throw PhplusError("tried to get size of " + getString(), INTERNAL_ERROR);
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movl 0x48(%rdi), %eax
addl $-0x2, %eax
cmpl $0x5, %eax
jae 0x3ede4
pushq $0x17
popq %rcx
btl %eax, %ecx
jae 0x3ede4
movl %eax, %eax
leaq 0x19749(%rip), %rcx     # 0x58520
movq (%rcx,%rax,8), %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x19917(%rip), %rsi     # 0x5871b
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x11ff8
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19f06
xorl %ebp, %ebp
leaq 0x38760(%rip), %rsi     # 0x77598
leaq -0x2d7ad(%rip), %rdx    # 0x11692
movq %rbx, %rdi
callq 0xa4e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc984
leaq 0x30(%rsp), %rdi
callq 0xa558
jmp 0x3ee66
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xa558
testb %bpl, %bpl
jne 0x3ee7a
jmp 0x3ee82
movq %rax, %r14
movq %rbx, %rdi
callq 0xa230
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: PtrType::getCppLiteral[abi:cxx11](void*, CppProgram*)
string getCppLiteral(void * data, CppProgram * prog)
	{
		string name=to_string((long long)data);
		prog->declareGlobal(name, type, type->getCppLiteral(*(void**)data, prog));
		string out="&"+prog->getGlobalNames()->getCpp(name);
		return out;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x3f69b
leaq 0x48(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12c0a
movq 0x48(%r12), %rsi
movq (%r15), %rdx
movq (%rsi), %rax
leaq 0x68(%rsp), %rdi
movq %r14, %rcx
callq *0x18(%rax)
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %r14, %rdi
callq 0x16f74
leaq 0x68(%rsp), %rdi
callq 0xa558
leaq 0x10(%rsp), %rdi
callq 0xc984
addq $0xf8, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x185da
movq (%r15), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1439e
leaq 0x18b23(%rip), %rsi     # 0x580ca
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x11ff8
leaq 0x48(%rsp), %rdi
callq 0xa558
leaq 0x20(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xa558
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x3f5f6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x3f614
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xa558
jmp 0x3f60f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc984
leaq 0x28(%rsp), %rdi
callq 0xa558
movq %rbx, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleType::getString[abi:cxx11]()
string getString()
	{
		string out;
		
		out+="{";
		
		for (int i=0; i<int(subTypes->size()); i++)
		{
			if (i)
				out+=", ";
			
			out+=(*subTypes)[i].name+": "+(*subTypes)[i].type->getString();
		}
		
		out+="} (tuple)";
		
		return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x14b76(%rip), %rsi     # 0x5457c
movq %rdi, (%rsp)
callq 0xa520
xorl %r15d, %r15d
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x48(%rsp), %rbp
xorl %ebx, %ebx
movq 0x48(%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cltq
cmpq %rax, %rbx
jge 0x3fac5
testq %r15, %r15
je 0x3fa60
movq (%rsp), %rdi
leaq 0x18441(%rip), %rsi     # 0x57e95
callq 0xa520
movq 0x48(%r14), %rax
movq (%rax), %rsi
addq %r15, %rsi
movq %r12, %rdi
leaq 0x1a21f(%rip), %rdx     # 0x59c8c
callq 0x11fb8
movq 0x48(%r14), %rax
movq (%rax), %rax
movq 0x20(%rax,%r15), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1205e
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0xa540
movq %rbp, %rdi
callq 0xa558
movq %r13, %rdi
callq 0xa558
movq %r12, %rdi
callq 0xa558
incq %rbx
addq $0x30, %r15
jmp 0x3fa23
leaq 0x18e38(%rip), %rsi     # 0x58904
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0xa520
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fb0c
jmp 0x3fb0c
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xa558
jmp 0x3fb00
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x3fb14
movq %rax, %r14
jmp 0x3fb1e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xa558
movq (%rsp), %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleType::getCompactString[abi:cxx11]()
string getCompactString()
	{
		string out;
		
		out+="Tt_";
		
		for (int i=0; i<int(subTypes->size()); i++)
		{
			//out+=(*subTypes)[i].name.size()+"_"+(*subTypes)[i].name+"_"+(*subTypes)[i].type->getCompactString()+"_";
			out+=(*subTypes)[i].type->getCompactString()+"_";
		}
		
		out+="tT";
		
		return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x18db3(%rip), %rsi     # 0x5890e
callq 0xa520
pushq $0x20
popq %rbp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r13
movq 0x48(%r14), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0x30
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r12
jge 0x3fbd0
movq (%rcx,%rbp), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r15, %rsi
leaq 0x19627(%rip), %rdx     # 0x591ce
callq 0xc882
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa540
movq %r13, %rdi
callq 0xa558
movq %r15, %rdi
callq 0xa558
incq %r12
addq $0x30, %rbp
jmp 0x3fb70
leaq 0x18d3b(%rip), %rsi     # 0x58912
movq %rbx, %rdi
callq 0xa520
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fc11
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xa558
jmp 0x3fc05
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa558
jmp 0x3fc14
movq %rax, %r14
movq %rbx, %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleType::getCppLiteral[abi:cxx11](void*, CppProgram*)
string getCppLiteral(void * data, CppProgram * prog)
	{
		if (subTypes->size()==1)
		{
			return (*subTypes)[0].type->getCppLiteral(data, prog);
		}
		
		string out;
		out+=prog->getTypeCode(shared_from_this());
		
		out+="(";
		
		for (int i=0; i<int(subTypes->size()); i++)
		{
			if (i)
				out+=", ";
			
			out+=(*subTypes)[i].type->getCppLiteral((char*)data+getSubType((*subTypes)[i].name).offset, prog);
		}
		
		out+=")";
		
		return out;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x48(%rsi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
cmpq $0x30, %rcx
jne 0x3fc6a
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x18(%rax)
jmp 0x3fdac
movq %rsi, %r12
leaq 0x10(%r15), %rax
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
addq $0x8, %rsi
leaq 0x20(%rsp), %rdi
movq %r15, 0x8(%rsp)
callq 0x4007c
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x15e88
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0xa540
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa558
leaq 0x28(%rsp), %rdi
callq 0xc984
leaq 0x19ccb(%rip), %rsi     # 0x599a0
movq %r15, %rdi
callq 0xa520
xorl %r14d, %r14d
leaq 0x68(%rsp), %rbp
leaq 0x30(%rsp), %r13
xorl %ebx, %ebx
movq 0x48(%r12), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cltq
cmpq %rax, %rbx
jge 0x3fd9d
testq %r14, %r14
je 0x3fd2a
movq %r15, %rdi
leaq 0x18178(%rip), %rsi     # 0x57e95
callq 0xa520
movq 0x48(%r12), %rax
movq (%rax), %rsi
movq 0x20(%rsi,%r14), %r15
addq %r14, %rsi
movq %rbp, %rdi
callq 0xa3b0
movq (%r12), %rax
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq *0x50(%rax)
movq 0x50(%rsp), %rdx
addq 0x10(%rsp), %rdx
movq (%r15), %rax
movq %r13, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rcx
callq *0x18(%rax)
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xa540
movq %r13, %rdi
callq 0xa558
leaq 0x60(%rsp), %rdi
callq 0xc984
movq %rbp, %rdi
callq 0xa558
incq %rbx
addq $0x30, %r14
jmp 0x3fcec
leaq 0x186f5(%rip), %rsi     # 0x58499
movq %r15, %rdi
callq 0xa520
movq %r15, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xa558
jmp 0x3fdd3
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc984
jmp 0x3fe15
jmp 0x3fe03
jmp 0x3fe03
jmp 0x3fe03
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xa558
jmp 0x3fdf7
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0xc984
jmp 0x3fe0b
movq %rax, %r14
jmp 0x3fe15
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xa558
movq 0x8(%rsp), %rdi
callq 0xa558
movq %r14, %rdi
callq 0xa500
nop
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/Type.cpp
// Function: TupleType::getSubType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
OffsetAndType getSubType(string name)
	{
		size_t offset=0;
		
		for (auto i: *subTypes)
		{
			if (i.name==name)
				return {offset, i.type};
			else
				offset+=i.type->getSize();
		}
		
		return {0, nullptr};
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq 0x48(%rsi), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq %rdi, 0x8(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x18(%rsp), %rbp
cmpq %r13, %r15
je 0x3ff2f
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1848c
movq %rbp, %rdi
movq %r14, %rsi
callq 0xcdda
movl %eax, %r12d
testb %al, %al
je 0x3ff0e
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x12c0a
jmp 0x3ff1c
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
addq %rax, %rbx
movq %rbp, %rdi
callq 0x12f68
addq $0x30, %r15
testb %r12b, %r12b
je 0x3fed3
jmp 0x3ff3f
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12f68
movq %rbx, %rdi
callq 0xa500
// File: /workspace/github_cpp_makefile_star2_O2/menhits[P]phplus/src/msclStringFuncs.cpp
// Function: substringMatches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool substringMatches(const string& in, int pos, const string& subStr)
{
	//check if the substring extends past the string size
	if (in.size()<pos+subStr.size())
		return false;
	
	for (unsigned i=0; i<subStr.size(); ++i)
	{
		if (in[i+pos]!=subStr[i])
			return false;
	}
	
	return true;
}

// Assembly:
movslq %esi, %r9
movq 0x8(%rdx), %rcx
addq %rcx, %r9
xorl %r8d, %r8d
movl $0x0, %eax
cmpq %r9, 0x8(%rdi)
jb 0x4193f
movq (%rdi), %rdi
movq (%rdx), %rdx
movl %r8d, %r9d
cmpq %r9, %rcx
setbe %al
jbe 0x4193f
leal (%rsi,%r9), %r8d
movb (%rdi,%r8), %r10b
leal 0x1(%r9), %r8d
cmpb (%rdx,%r9), %r10b
je 0x41922
retq