LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xd8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
movq %rsi, 0x28(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x9fd50
leaq 0xa8(%rsp), %rdi
callq 0xb610
testb $0x1, %al
jne 0x9fc5e
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xb1a0
jmp 0x9fbd2
movq 0x20(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a920
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x88(%rsp), %rsi
callq 0x9f990
jmp 0x9fbff
leaq 0x68(%rsp), %rdi
callq 0x1a950
leaq 0x88(%rsp), %rdi
callq 0xb6e8
jmp 0x9fd19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x9fd2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1a950
leaq 0x88(%rsp), %rdi
callq 0xb6e8
jmp 0x9fd2e
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb690
movq 0x10(%rsp), %rdx
leaq 0x36236(%rip), %rsi     # 0xd5eaf
leaq 0x48(%rsp), %rdi
callq 0xb4c0
jmp 0x9fc85
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xfbe0
movq 0x8(%rsp), %rcx
leaq 0x7871f(%rip), %rdi     # 0x1183c3
leaq 0x48(%rsp), %rsi
movl $0x3, %edx
callq 0x34c70
jmp 0x9fcb5
leaq 0x30(%rsp), %rdi
callq 0xfc00
leaq 0x48(%rsp), %rdi
callq 0xb6e8
leaq 0x47(%rsp), %rdi
callq 0xb3f0
jmp 0x9fd19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x9fd0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfc00
leaq 0x48(%rsp), %rdi
callq 0xb6e8
leaq 0x47(%rsp), %rdi
callq 0xb3f0
jmp 0x9fd2e
leaq 0xa8(%rsp), %rdi
callq 0xb6e8
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0xb6e8
movq 0x80(%rsp), %rdi
callq 0xb680
nopl (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xa0ac0
testb $0x1, %al
jne 0xa00ba
jmp 0xa0170
movl $0x58, %edi
callq 0xb390
movq 0x38(%rsp), %rsi
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movb $0x1, 0x9b(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa06c0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movzbl 0xb7(%rsp), %edx
andl $0x1, %edx
callq 0xa06f0
jmp 0xa0109
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdi
movb $0x0, 0x9b(%rsp)
callq 0xa0a20
jmp 0xa0122
leaq 0xa8(%rsp), %rdi
callq 0x1e690
jmp 0xa0282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1e690
testb $0x1, 0x9b(%rsp)
jne 0xa0161
jmp 0xa016b
movq 0x10(%rsp), %rdi
callq 0xb350
jmp 0xa028f
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb690
movq 0x8(%rsp), %rdx
leaq 0x3542d(%rip), %rsi     # 0xd55b8
leaq 0x58(%rsp), %rdi
callq 0xb4c0
jmp 0xa0197
leaq 0x35cee(%rip), %rdx     # 0xd5e8c
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xfa60
jmp 0xa01af
xorl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xfbe0
movq (%rsp), %rcx
leaq 0x781f7(%rip), %rdi     # 0x1183c3
leaq 0x78(%rsp), %rsi
movl $0x3, %edx
callq 0x34c70
jmp 0xa01dd
leaq 0x40(%rsp), %rdi
callq 0xfc00
leaq 0x78(%rsp), %rdi
callq 0xb6e8
leaq 0x58(%rsp), %rdi
callq 0xb6e8
leaq 0x57(%rsp), %rdi
callq 0xb3f0
jmp 0xa0271
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xa0265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xa025b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfc00
leaq 0x78(%rsp), %rdi
callq 0xb6e8
leaq 0x58(%rsp), %rdi
callq 0xb6e8
leaq 0x57(%rsp), %rdi
callq 0xb3f0
jmp 0xa028f
movq 0x28(%rsp), %rdi
leaq 0x7822b(%rip), %rsi     # 0x1184a8
callq 0x1a920
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0xb680
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x48(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x4, %eax
ja 0xa1687
movq 0x18(%rsp), %rax
leaq 0x3475e(%rip), %rcx     # 0xd5d98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, 0x90(%rsp)
jmp 0xa1774
movq $0x1, 0x90(%rsp)
jmp 0xa1774
movq $0x4, 0x90(%rsp)
jmp 0xa1774
movq $0x8, 0x90(%rsp)
jmp 0xa1774
movb $0x1, 0x27(%rsp)
movl $0x38, %edi
callq 0xb1f0
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq 0x48(%rsp), %rdi
callq *%rax
jmp 0xa16b0
leaq 0x348a0(%rip), %rsi     # 0xd5f57
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1bcf0
jmp 0xa16c8
xorl %eax, %eax
movl %eax, %esi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xfbe0
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x68(%rsp), %rsi
movl $0x3, %edx
callq 0x35600
jmp 0xa16f4
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
leaq 0x73ec3(%rip), %rsi     # 0x1155c8
leaq -0x8709c(%rip), %rdx    # 0x1a670
callq 0xb640
jmp 0xa178e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xa175f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xa1755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xfc00
leaq 0x68(%rsp), %rdi
callq 0xb6e8
leaq 0x48(%rsp), %rdi
callq 0xb6e8
testb $0x1, 0x27(%rsp)
jne 0xa1768
jmp 0xa1772
movq 0x8(%rsp), %rdi
callq 0xb2d0
jmp 0xa1784
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xb680
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0xa2870
movq 0x10(%rsp), %rsi
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x48, %rsi
movq %rsi, 0x20(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1a920
movq 0x20(%rsp), %rdi
callq 0x1a660
movq %rax, %rsi
movq 0xc0(%rsp), %rax
movq (%rax), %rdx
movq 0xb8(%rsp), %rcx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x68(%rsp), %rdi
callq *%rax
jmp 0xa260d
movq 0x18(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rcx
callq 0x2a510
jmp 0xa262e
leaq 0x68(%rsp), %rdi
callq 0xb6e8
leaq 0x88(%rsp), %rdi
callq 0x1a950
movb $0x0, 0x5b(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa29c0
jmp 0xa265e
leaq 0x28(%rsp), %rdi
callq 0x2d6b0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x23eb0
jmp 0xa267f
movq (%rsp), %rdi
leaq 0x33295(%rip), %rsi     # 0xd591f
leaq 0x38(%rsp), %rdx
callq 0x1bcf0
jmp 0xa2696
leaq 0x38(%rsp), %rdi
callq 0xb6e8
leaq 0x28(%rsp), %rdi
callq 0x2d6c0
movb $0x1, 0x5b(%rsp)
testb $0x1, 0x5b(%rsp)
jne 0xa2740
jmp 0xa2737
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa26e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xb6e8
leaq 0x88(%rsp), %rdi
callq 0x1a950
jmp 0xa275a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa275a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa272b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb6e8
leaq 0x28(%rsp), %rdi
callq 0x2d6c0
jmp 0xa275a
movq (%rsp), %rdi
callq 0xb6e8
leaq 0x98(%rsp), %rdi
callq 0xb6e8
movq 0x8(%rsp), %rax
addq $0xd8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0xb6e8
movq 0x60(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0xb4e0
movq 0x28(%rsp), %rdi
leaq 0x2e2e8(%rip), %rsi     # 0xd14d2
callq 0xb360
jmp 0xa31f1
movl $0x0, 0x90(%rsp)
movq 0x20(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x48, %rdi
callq 0xa0ae0
movq %rax, %rdi
callq 0x2df40
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xa33a0
cmpl $0x0, 0x90(%rsp)
je 0xa3264
movq 0x28(%rsp), %rdi
leaq 0x324a8(%rip), %rsi     # 0xd56ea
callq 0xb360
jmp 0xa3249
jmp 0xa3264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xa33dc
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0b20
movq %rax, 0x8(%rsp)
jmp 0xa3279
movq 0x8(%rsp), %rdi
movslq 0x90(%rsp), %rsi
callq 0x2df60
movq %rax, %rsi
leaq 0x3423f(%rip), %rdx     # 0xd74d4
leaq 0x50(%rsp), %rdi
callq 0x1ba50
jmp 0xa32a1
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0b20
movq %rax, (%rsp)
jmp 0xa32b5
movq (%rsp), %rdi
movslq 0x90(%rsp), %rsi
callq 0x2df60
movq %rax, %rdi
addq $0x20, %rdi
callq 0x1a660
movq %rax, %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq 0x30(%rsp), %rdi
callq *%rax
jmp 0xa32e5
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1bf20
jmp 0xa32fb
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb470
jmp 0xa330c
leaq 0x70(%rsp), %rdi
callq 0xb6e8
leaq 0x30(%rsp), %rdi
callq 0xb6e8
leaq 0x50(%rsp), %rdi
callq 0xb6e8
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0xa31fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xa3394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xa338a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xb6e8
leaq 0x30(%rsp), %rdi
callq 0xb6e8
leaq 0x50(%rsp), %rdi
callq 0xb6e8
jmp 0xa33dc
movq 0x28(%rsp), %rdi
leaq 0x32d94(%rip), %rsi     # 0xd6140
callq 0xb360
jmp 0xa33b3
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0xa33cf
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x98(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x87(%rsp)
callq 0xb4e0
movq 0x28(%rsp), %rdi
leaq 0x32d00(%rip), %rsi     # 0xd614a
callq 0xb360
jmp 0xa3451
movl $0x0, 0x70(%rsp)
movq 0x20(%rsp), %rdi
movl 0x70(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x48, %rdi
callq 0xa0ae0
movq %rax, %rdi
callq 0x2df40
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xa355a
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0b20
movq %rax, 0x8(%rsp)
jmp 0xa349b
movq 0x8(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x2df60
movq %rax, %rdi
addq $0x20, %rdi
callq 0x1a660
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x30(%rsp), %rdi
callq *%rax
jmp 0xa34c9
leaq 0x33546(%rip), %rdx     # 0xd6a16
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfa60
jmp 0xa34e1
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb470
jmp 0xa34f2
leaq 0x50(%rsp), %rdi
callq 0xb6e8
leaq 0x30(%rsp), %rdi
callq 0xb6e8
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0xa3459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xa3596
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xa354e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xb6e8
leaq 0x30(%rsp), %rdi
callq 0xb6e8
jmp 0xa3596
movq 0x28(%rsp), %rdi
leaq 0x32be8(%rip), %rsi     # 0xd614e
callq 0xb360
jmp 0xa356d
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0xa3589
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x78(%rsp), %rdi
callq 0xb680
nopw (%rax,%rax)
// File: menhits[P]phplus/src/Type.cpp
// Function: TupleType::getSize()
size_t getSize()
	{
		size_t sum=0;
		
		for (auto i: *subTypes)
		{
			sum+=i.type->getSize();
		}
		
		return sum;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq $0x0, 0x68(%rsp)
addq $0x48, %rdi
callq 0xa0b20
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2df80
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2dfb0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2dfe0
testb $0x1, %al
jne 0xa39e8
jmp 0xa3a5b
leaq 0x58(%rsp), %rdi
callq 0x2e020
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x2e030
leaq 0x40(%rsp), %rdi
callq 0x1a660
movq %rax, %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0xa3a1c
movq 0x8(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1e980
leaq 0x58(%rsp), %rdi
callq 0x2e0c0
jmp 0xa39d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1e980
jmp 0xa3a65
movq 0x68(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xb680
nop
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq $0x0, 0x88(%rsp)
addq $0x48, %rdi
callq 0xa0b20
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2df80
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2dfb0
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2dfe0
testb $0x1, %al
jne 0xa3b12
jmp 0xa3be7
leaq 0x78(%rsp), %rdi
callq 0x2e020
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x2e030
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x112a0
testb $0x1, %al
jne 0xa3b3e
jmp 0xa3b6a
movq 0x18(%rsp), %rdi
movq 0x88(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x40(%rsp), %rsi
addq $0x20, %rsi
callq 0x1a920
movl $0x1, 0x3c(%rsp)
jmp 0xa3bc0
leaq 0x60(%rsp), %rdi
callq 0x1a660
movq %rax, %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0xa3b87
movq 0x8(%rsp), %rax
addq 0x88(%rsp), %rax
movq %rax, 0x88(%rsp)
jmp 0xa3bb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1e980
jmp 0xa3c0d
movl $0x0, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1e980
movl 0x3c(%rsp), %eax
testl %eax, %eax
je 0xa3bd6
jmp 0xa3bd4
jmp 0xa3c00
jmp 0xa3bd8
leaq 0x78(%rsp), %rdi
callq 0x2e0c0
jmp 0xa3afa
movq 0x18(%rsp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1dcb0
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xb680
nopw (%rax,%rax)
// File: menhits[P]phplus/src/Type.cpp
// Function: TupleType::matchesSameTypeType(std::shared_ptr<TypeBase>)
bool matchesSameTypeType(Type other)
	{
		auto o=(TupleType*)(&(*other));
		
		if (!isAnonymous && !o->isAnonymous)
			return false;
		
		if (subTypes->size()!=o->subTypes->size())
			return false;
		
		for (int i=0; i<int(subTypes->size()); i++)
		{
			//if ((*subTypes)[i].name!=(*o->subTypes)[i].name)
			//	return false;
			
			//if ((*subTypes)[i].type!=(*o->subTypes)[i].type)
			//	return false;
			
			if (!(*subTypes)[i].type->matches((*o->subTypes)[i].type))
				return false;
		}
		
		return true;
	}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %rax
movq 0x30(%rsp), %rdi
movq %rax, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0xa2260
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x68(%rsp)
testb $0x1, 0x50(%rax)
jne 0xa3c98
movq 0x68(%rsp), %rax
testb $0x1, 0x50(%rax)
jne 0xa3c98
movb $0x0, 0x87(%rsp)
jmp 0xa3de6
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0ae0
movq %rax, %rdi
callq 0x2df40
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0ae0
movq %rax, %rdi
callq 0x2df40
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
je 0xa3ce3
movb $0x0, 0x87(%rsp)
jmp 0xa3de6
movl $0x0, 0x64(%rsp)
movq 0x38(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x24(%rsp)
addq $0x48, %rdi
callq 0xa0ae0
movq %rax, %rdi
callq 0x2df40
movq %rax, %rcx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0xa3dde
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0b20
movq %rax, %rdi
movslq 0x64(%rsp), %rsi
callq 0x2df60
movq %rax, %rdi
addq $0x20, %rdi
callq 0x1a660
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
addq $0x48, %rdi
callq 0xa0b20
movq %rax, %rdi
movslq 0x64(%rsp), %rsi
callq 0x2df60
movq %rax, %rsi
addq $0x20, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a920
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9f1a0
movb %al, 0x23(%rsp)
jmp 0xa3d8a
movb 0x23(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1a950
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa3da8
jmp 0xa3dcc
movb $0x0, 0x87(%rsp)
jmp 0xa3de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1a950
jmp 0xa3df7
jmp 0xa3dce
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xa3ceb
movb $0x1, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0xb2a0
movq %rax, 0x18(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb2a0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xa8061
movb $0x0, 0x47(%rsp)
jmp 0xa80df
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xa80da
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
addl 0x34(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0xb400
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xb400
movq %rax, %rcx
movl 0x4(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xa80cb
movb $0x0, 0x47(%rsp)
jmp 0xa80df
jmp 0xa80cd
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa8069
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: menhits[P]phplus/src/msclStringFuncs.cpp
// Function: searchInString(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&, int)
int searchInString(const string& in, const string& pattern, int startPos)
{
	for (unsigned i=startPos; i<in.size(); i++)
	{
		if (substringMatches(in, i, pattern))
			return i;
	}
	
	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xa815a
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xa8010
testb $0x1, %al
jne 0xa8141
jmp 0xa814b
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xa8162
jmp 0xa814d
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xa810a
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xb4e0
movl $0x0, 0x70(%rsp)
jmp 0xa81b5
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movl 0x70(%rsp), %edx
callq 0xa80f0
movl %eax, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
jge 0xa81de
jmp 0xa8286
movq 0x88(%rsp), %rsi
movslq 0x70(%rsp), %rdx
movl %edx, %ecx
movl 0x6c(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x48(%rsp), %rdi
callq 0xb3a0
jmp 0xa8202
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb470
jmp 0xa8213
leaq 0x48(%rsp), %rdi
callq 0xb6e8
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xb470
jmp 0xa822e
movslq 0x6c(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movl %eax, 0x70(%rsp)
jmp 0xa8281
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xa8300
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xb6e8
jmp 0xa8300
jmp 0xa81b3
movq 0x88(%rsp), %rsi
movslq 0x70(%rsp), %rdx
leaq 0x18(%rsp), %rdi
movq $-0x1, %rcx
callq 0xb3a0
jmp 0xa82a6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xb470
jmp 0xa82b7
leaq 0x18(%rsp), %rdi
callq 0xb6e8
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0xa82f3
jmp 0xa82e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb6e8
jmp 0xa8300
movq 0x8(%rsp), %rdi
callq 0xb6e8
movq 0x10(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0xb6e8
movq 0x40(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x58(%rsp), %rdi
callq 0xb2a0
cmpq $0x1, %rax
jae 0xa8350
jmp 0xa8428
jmp 0xa8352
movl 0x4c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0xa8428
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0xa80f0
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jge 0xa839f
movq 0x60(%rsp), %rdi
callq 0xb2a0
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rsi
movslq 0x4c(%rsp), %rdx
movl %edx, %ecx
movl 0x48(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb3a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1a5a0
jmp 0xa83de
leaq 0x28(%rsp), %rdi
callq 0xb6e8
movslq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movl %eax, 0x4c(%rsp)
jmp 0xa8352
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb6e8
jmp 0xa842d
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xb680
nopw (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movb $0x0, 0x9b(%rsp)
callq 0xb4e0
movl $0x0, 0x94(%rsp)
movl $0x0, 0x90(%rsp)
movl 0x90(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0xa84ea
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xb470
jmp 0xa84bc
jmp 0xa84be
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0xa849b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xa86d9
movl $0x0, 0x80(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movl 0x1c(%rsp), %eax
subq $0x1, %rcx
cmpl %ecx, %eax
jge 0xa8609
movq 0xa8(%rsp), %rdi
movslq 0x80(%rsp), %rsi
callq 0xb400
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xa85f1
movq 0xa8(%rsp), %rsi
movslq 0x94(%rsp), %rdx
movl %edx, %ecx
movl 0x80(%rsp), %eax
subl %ecx, %eax
incl %eax
movslq %eax, %rcx
leaq 0x60(%rsp), %rdi
callq 0xb3a0
jmp 0xa856d
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xb470
jmp 0xa857e
leaq 0x60(%rsp), %rdi
callq 0xb6e8
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0xa85e0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xb470
jmp 0xa85ae
jmp 0xa85b0
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xa8590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xb6e8
jmp 0xa86d9
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0xa85f3
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0xa84f5
movl 0x94(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jg 0xa86b0
movq 0xa8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movslq 0x94(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb2a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movslq 0x94(%rsp), %rax
subq %rax, %rcx
leaq 0x38(%rsp), %rdi
callq 0xb3a0
jmp 0xa8673
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xb470
jmp 0xa8684
leaq 0x38(%rsp), %rdi
callq 0xb6e8
jmp 0xa86b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb6e8
jmp 0xa86d9
movb $0x1, 0x9b(%rsp)
testb $0x1, 0x9b(%rsp)
jne 0xa86cc
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x88(%rsp), %rdi
callq 0xb680
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl $0xffffffff, 0x50(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x54(%rsp)
jge 0xa9529
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb690
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x28529(%rip), %rsi     # 0xd1a1f
callq 0xb4c0
jmp 0xa94fd
leaq 0x4b(%rsp), %rdi
callq 0xb3f0
jmp 0xa9662
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0xb3f0
jmp 0xa966c
cmpl $0x1, 0x54(%rsp)
jne 0xa9538
movl $0x0, 0x50(%rsp)
jmp 0xa953a
movl $0x1, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xb2a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xa95c6
movq 0x58(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0xb400
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xa95b7
cmpl $0x0, 0x50(%rsp)
jge 0xa95ab
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x54(%rsp), %eax
jne 0xa95a9
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0xa95b5
movl 0x34(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0xa95c6
jmp 0xa95b7
jmp 0xa95b9
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xa954a
movl 0x50(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xa95f1
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movslq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %eax
subl 0x50(%rsp), %eax
movslq %eax, %rcx
callq 0xb3a0
jmp 0xa9662
cmpl $0x0, 0x50(%rsp)
jl 0xa9615
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movslq 0x50(%rsp), %rdx
movq $-0x1, %rcx
callq 0xb3a0
jmp 0xa9662
leaq 0x33(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb690
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x283ea(%rip), %rsi     # 0xd1a1f
callq 0xb4c0
jmp 0xa963c
leaq 0x33(%rsp), %rdi
callq 0xb3f0
jmp 0xa9662
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x33(%rsp), %rdi
callq 0xb3f0
jmp 0xa966c
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
andb $0x1, %cl
movb %cl, 0xaf(%rsp)
andb $0x1, %al
movb %al, 0xae(%rsp)
movl %r9d, 0xa8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1a570
cmpl $0x0, 0xa8(%rsp)
jge 0xaadea
callq 0xaaf70
movl %eax, 0x1c(%rsp)
jmp 0xaadc1
movl 0x1c(%rsp), %eax
subl $0x4, %eax
movl %eax, 0xa8(%rsp)
jmp 0xaadea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xaaf4a
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb690
movq 0x10(%rsp), %rdx
leaq 0x270e6(%rip), %rsi     # 0xd1ef8
leaq 0x60(%rsp), %rdi
callq 0xb4c0
jmp 0xaae1e
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0xa8320
jmp 0xaae37
leaq 0x60(%rsp), %rdi
callq 0xb6e8
leaq 0x5f(%rsp), %rdi
callq 0xb3f0
leaq 0x90(%rsp), %rdi
callq 0xa8b40
jmp 0xaae5a
movq 0x20(%rsp), %rsi
movb $0x0, 0x5e(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb1a0
jmp 0xaae70
movq 0x28(%rsp), %rdi
movzbl 0xaf(%rsp), %ecx
andl $0x1, %ecx
decl %ecx
orl $0x1, %ecx
movl 0xa8(%rsp), %r9d
movzbl 0xae(%rsp), %r8d
andl $0x1, %r8d
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xa9680
jmp 0xaaeae
leaq 0x38(%rsp), %rdi
callq 0xb6e8
movb $0x1, 0x5e(%rsp)
testb $0x1, 0x5e(%rsp)
jne 0xaaf30
jmp 0xaaf26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xaaefa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xb6e8
leaq 0x5f(%rsp), %rdi
callq 0xb3f0
jmp 0xaaf4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb6e8
jmp 0xaaf4a
movq 0x28(%rsp), %rdi
callq 0xb6e8
leaq 0x90(%rsp), %rdi
callq 0x1a600
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x1a600
movq 0x88(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movsd %xmm0, 0xa8(%rsp)
cvttsd2si 0xa8(%rsp), %rax
movq %rax, 0xa0(%rsp)
movsd 0xa8(%rsp), %xmm0
cvtsi2sdq 0xa0(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd 0x2a502(%rip), %xmm1    # 0xd69f8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
jge 0xac523
imulq $-0x1, 0x98(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
cmpq $0x9, %rdx
jne 0xac54f
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0xac551
xorl %eax, %eax
cmpq $0x0, 0x98(%rsp)
movb %al, 0x17(%rsp)
jle 0xac581
movq 0x98(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
setne %al
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xac58b
jmp 0xac5a7
movq 0x98(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, 0x98(%rsp)
jmp 0xac551
movq 0xa0(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa2870
movq 0x8(%rsp), %rsi
leaq 0x28eaf(%rip), %rdx     # 0xd5479
leaq 0x78(%rsp), %rdi
callq 0xfa60
jmp 0xac5d6
movq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa2870
jmp 0xac5ea
movq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1bf20
jmp 0xac600
leaq 0x28(%rsp), %rdi
callq 0xb6e8
leaq 0x78(%rsp), %rdi
callq 0xb6e8
leaq 0x58(%rsp), %rdi
callq 0xb6e8
movq 0x20(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xac66d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xac663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb6e8
leaq 0x78(%rsp), %rdi
callq 0xb6e8
leaq 0x58(%rsp), %rdi
callq 0xb6e8
movq 0x50(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb2a0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xac757
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xac72a
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xac72a
movq 0x10(%rsp), %rdi
imull $0xa, 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movslq 0x18(%rsp), %rsi
callq 0xb6d0
movq %rax, %rcx
movl 0x8(%rsp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, 0x1c(%rsp)
jmp 0xac745
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xac743
jmp 0xac757
jmp 0xac745
jmp 0xac747
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xac6ae
movq 0x10(%rsp), %rdi
callq 0xb2a0
cmpq $0x0, %rax
jbe 0xac786
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xac786
imull $-0x1, 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xb2a0
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xac8fa
cmpl $0x1, 0x24(%rsp)
jne 0xac880
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xac85d
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xac85d
movq 0x18(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsd 0x8(%rsp), %xmm0
movsbl (%rax), %eax
cvtsi2sd %eax, %xmm1
movsd 0x2916f(%rip), %xmm2    # 0xd59b0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x2a1b7(%rip), %xmm1    # 0xd6a08
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xac87e
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xac87c
movl $0xa, 0x24(%rsp)
jmp 0xac87e
jmp 0xac8e8
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xac8e6
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xac8e6
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xb6d0
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0x24(%rsp), %xmm1
divsd %xmm1, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
imull $0xa, 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xac8e8
jmp 0xac8ea
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xac7b7
movq 0x18(%rsp), %rdi
callq 0xb2a0
cmpq $0x0, %rax
jbe 0xac934
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb6d0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xac934
movsd 0x2a0d8(%rip), %xmm0    # 0xd6a00
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: menhits[P]phplus/src/msclStringFuncs.cpp
// Function: getRandChar()
char getRandChar()
{
	static unsigned int seed = 1;
	//seed = (unsigned)newseed & 0x7fffffffU;
	
	seed = (seed * 1103515245U + 12345U) & 0x7fffffffU;
	
	int num=seed%(26+26+10);
	
	if (num<26)
	{
		return num+'a';
	}
	else if (num<26+26)
	{
		return num-26+'A';
	}
	else if (num<26+26+10)
	{
		return num-26-26+'0';
	}
	
	return '_'; // if I did my arithmetic right, this shouldn't happen
}

// Assembly:
imull $0x41c64e6d, 0x6b44e(%rip), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0x6b43e(%rip)     # 0x1183a8
movl 0x6b438(%rip), %eax     # 0x1183a8
movl $0x3e, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x8(%rsp)
cmpl $0x1a, -0x8(%rsp)
jge 0xacf91
movl -0x8(%rsp), %eax
addl $0x61, %eax
movb %al, -0x1(%rsp)
jmp 0xacfcb
cmpl $0x34, -0x8(%rsp)
jge 0xacfa8
movl -0x8(%rsp), %eax
subl $0x1a, %eax
addl $0x41, %eax
movb %al, -0x1(%rsp)
jmp 0xacfcb
cmpl $0x3e, -0x8(%rsp)
jge 0xacfc2
movl -0x8(%rsp), %eax
subl $0x1a, %eax
subl $0x1a, %eax
addl $0x30, %eax
movb %al, -0x1(%rsp)
jmp 0xacfcb
jmp 0xacfc4
jmp 0xacfc6
movb $0x5f, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
// File: 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:
subq $0xe8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x67ad6(%rip), %rcx     # 0x117090
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x60(%rsp)
leaq 0xc7(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0xb690
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rdx
leaq 0x22436(%rip), %rsi     # 0xd1a1f
callq 0xb4c0
jmp 0xaf5f0
leaq 0xc7(%rsp), %rdi
callq 0xb3f0
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1d9a0
movq 0x58(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x28(%rsp)
callq 0x1d9a0
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x30(%rsp)
callq 0x1d9a0
movq 0x58(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, 0x38(%rsp)
callq 0xb4e0
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x1a4e0
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rdi
addq $0x38, %rdi
callq 0x1a4e0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0x1a4e0
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d820
testb $0x1, %al
jne 0xaf696
jmp 0xaf6c0
movq 0x58(%rsp), %rdi
addq $0x38, %rdi
callq 0x1d820
testb $0x1, %al
jne 0xaf6aa
jmp 0xaf6c0
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0x1d820
testb $0x1, %al
jne 0xaf80f
movb $0x1, 0x77(%rsp)
movl $0x38, %edi
callq 0xb1f0
movq %rax, 0x10(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb690
movq 0x18(%rsp), %rdx
leaq 0x27452(%rip), %rsi     # 0xd6b44
leaq 0x90(%rsp), %rdi
callq 0xb4c0
jmp 0xaf701
xorl %eax, %eax
movl %eax, %esi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xfbe0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x90(%rsp), %rsi
movl $0x3, %edx
callq 0x35600
jmp 0xaf732
movq 0x10(%rsp), %rdi
movb $0x0, 0x77(%rsp)
leaq 0x65e85(%rip), %rsi     # 0x1155c8
leaq -0x950da(%rip), %rdx    # 0x1a670
callq 0xb640
jmp 0xaf824
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc7(%rsp), %rdi
callq 0xb3f0
jmp 0xaf817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xaf7bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xfc00
leaq 0x90(%rsp), %rdi
callq 0xb6e8
leaq 0x8f(%rsp), %rdi
callq 0xb3f0
testb $0x1, 0x77(%rsp)
jne 0xaf7d1
jmp 0xaf7db
movq 0x10(%rsp), %rdi
callq 0xb2d0
movq 0x38(%rsp), %rdi
callq 0xb6e8
movq 0x30(%rsp), %rdi
callq 0x1a950
movq 0x28(%rsp), %rdi
callq 0x1a950
movq 0x20(%rsp), %rdi
callq 0x1a950
movq 0x60(%rsp), %rdi
callq 0xb6e8
jmp 0xaf817
addq $0xe8, %rsp
retq
movq 0xb8(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, %edi
callq 0xb4a0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
addq $0x78, %rdi
callq 0x1bb50
movq %rax, %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movq %rdx, %rsi
callq *0x20(%rax)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0xb2ae0
movq (%rsp), %rdi
addq $0x88, %rdi
callq 0x1bb50
movq %rax, %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movq %rdx, %rsi
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xb2ad6
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
callq 0xb430
movq 0x10(%rsp), %rdi
callq 0xb430
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop