LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/Actions/VarAction.cpp
// Function: VarSetAction::execute(void*, void*)
void* execute(void* left, void* right)
	{
		if (!(*stackPtrPtr))
		{
			throw PhplusError("something fucked up big time. VarSetAction::execute called while stack pointer is still null", RUNTIME_ERROR);
		}
		
		//copy data on to the stack location of the var
		memcpy((char*)(*stackPtrPtr)+offset, right, inRightType->getSize());
		
		//return a new copy of the data
		void* out=malloc(returnType->getSize());
		memcpy(out, (char*)(*stackPtrPtr)+offset, inRightType->getSize());
		//return out;
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x78(%rdi), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x6d820
movq %rdx, %r14
movq %rdi, %rbx
addq 0x80(%rdi), %r15
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa270
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xea8e(%rip), %rsi      # 0x7c2cb
leaq 0xeae3(%rip), %rdx      # 0x7c327
leaq 0x18(%rsp), %rdi
callq 0xdf6a
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x200e4
xorl %ebp, %ebp
leaq 0x28dc3(%rip), %rsi     # 0x96638
leaq -0x58f84(%rip), %rdx    # 0x148f8
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d896
callq 0xdcba
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d8ad
callq 0xa2b0
jmp 0x6d8ad
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6d8ba
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/Actions/VarAction.cpp
// Function: VarSetAction::addToProg(std::shared_ptr<ActionData>, std::shared_ptr<ActionData>, CppProgram*)
void addToProg(Action inLeft, Action inRight, CppProgram* prog)
	{
		/*
		if ((nameHint=="me" || nameHint=="in") && getReturnType()->getType()==TypeBase::TUPLE)
		{
			if (prog->getExprLevel()>0)
			{
				throw PhplusError("can not set 'in' or 'me' inside expression in C++ because of some really dumb reason", INTERNAL_ERROR);
			}
			
			prog->pushBlock();
				prog->code(prog->getTypeCode(inRight->getReturnType()));
				prog->code(" tmp = ");
				prog->pushExpr();
					inRight->addToProg(prog);
				prog->popExpr();
				prog->endln();
				auto subs=*getReturnType()->getAllSubTypes();
				for (int i=0; i<(int)subs.size(); i++)
				{
					prog->name(subs[i].name);
					prog->code(" = ");
					prog->code("tmp."+(*inRight->getReturnType()->getAllSubTypes())[i].name);
					//prog->pushExpr();
						//getElemFromTupleAction(inRight->getReturnType(), (*inRight->getReturnType()->getAllSubTypes())[i].name)->addToProg(var, voidAction, prog);
					//prog->popExpr();
					prog->endln();
				}
			prog->popBlock();
		}
		else
		*/
		{
			prog->declareVar(nameHint, getInRightType());
			prog->name(nameHint);
			prog->code(" = ");
			prog->pushExpr();
			inRight->addToProg(prog);
			prog->popExpr();
			//if (prog->getExprLevel()==0)
			//	prog->endln();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x6d902
movq 0x2b6b4(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x6d8fe
incl 0x8(%rax)
jmp 0x6d902
lock
incl 0x8(%rax)
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x913c(%rip), %rdx      # 0x76a4f
leaq 0x38(%rsp), %rdi
movq %rdx, %rsi
callq 0xdf6a
addq $0x8, %r15
leaq 0x8(%rsp), %rdx
leaq 0x38(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c0c4
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d948
callq 0xa2b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6d957
callq 0xdcba
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
callq 0x185d6
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc005(%rip), %rsi      # 0x7997b
leaq 0xc001(%rip), %rdx      # 0x7997e
leaq 0x18(%rsp), %rdi
callq 0xdf6a
movq 0xa0(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1834e
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d9a7
callq 0xa2b0
movq 0xa0(%rbx), %rdi
callq 0x18b54
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4f248
movq 0xa0(%rbx), %rdi
callq 0x18bc6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6da15
callq 0xa2b0
jmp 0x6da15
movq %rax, %rbx
jmp 0x6da15
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x6da06
callq 0xa2b0
jmp 0x6da06
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6da15
callq 0xdcba
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/fileUtils.cpp
// Function: loadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void loadFile(string filepath, string& contents)
{
	std::fstream inFile;
	
	inFile.open(filepath);
	
	if (!inFile.is_open())
	{
		throw "tidak bisa membuka '"+filepath+"'";
	}
	else
	{
		stringstream strStream;
		strStream << inFile.rdbuf();//read the file
		contents = strStream.str();//str holds the content of the file
		inFile.close();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1a8(%rsp), %r14
movq %r14, %rdi
callq 0xa340
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0xa3c0
leaq 0x228(%rsp), %rdi
callq 0xa0c0
testb %al, %al
je 0x6e3d3
leaq 0x20(%rsp), %rdi
callq 0xa220
leaq 0x30(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0xa0a0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0xa4a0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa370
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6e38d
callq 0xa2b0
leaq 0x1a8(%rsp), %rdi
callq 0xa050
movq 0x2abd7(%rip), %rsi     # 0x98f78
leaq 0x20(%rsp), %rdi
callq 0xa250
leaq 0xa0(%rsp), %rdi
callq 0xa120
leaq 0x1a8(%rsp), %rdi
callq 0xa0b0
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xa1b0
movq %rax, %r14
leaq 0xe090(%rip), %rsi      # 0x7c477
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0xdbef
movb $0x1, %bpl
leaq 0xceac(%rip), %rdx      # 0x7b2aa
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6e5bd
xorl %ebp, %ebp
leaq 0x2953c(%rip), %rsi     # 0x97950
movq 0x2ab6d(%rip), %rdx     # 0x98f88
movq %r14, %rdi
callq 0xa4f0
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e441
callq 0xa2b0
jmp 0x6e441
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6e47a
movq %r14, %rdi
callq 0xa240
jmp 0x6e47a
jmp 0x6e459
jmp 0x6e454
movq %rax, %rbx
jmp 0x6e47a
movq %rax, %rbx
movq 0x2ab15(%rip), %rsi     # 0x98f78
leaq 0x20(%rsp), %rdi
callq 0xa250
leaq 0xa0(%rsp), %rdi
callq 0xa120
leaq 0x1a8(%rsp), %rdi
callq 0xa0b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/fileUtils.cpp
// Function: writeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void writeFile(string filepath, const string& contents)
{
	std::ofstream outFile;
	
	outFile.open(filepath);
	
	if (!outFile.is_open())
	{
		throw "error writing to '"+filepath+"'";
	}
	else
	{
		outFile << contents;
		
		outFile.close();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xa4e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0xa190
leaq 0x98(%rsp), %rdi
callq 0xa0c0
testb %al, %al
je 0x6e52b
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0xa320
leaq 0x28(%rsp), %rdi
callq 0xa430
movq 0x2aaa6(%rip), %rax     # 0x98f98
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0xa280
leaq 0x120(%rsp), %rdi
callq 0xa120
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0xdf4d(%rip), %rsi      # 0x7c48c
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xdbef
movb $0x1, %bpl
leaq 0xcd54(%rip), %rdx      # 0x7b2aa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e5bd
xorl %ebp, %ebp
leaq 0x293e4(%rip), %rsi     # 0x97950
movq 0x2aa15(%rip), %rdx     # 0x98f88
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e599
callq 0xa2b0
jmp 0x6e599
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6e5ab
movq %rbx, %rdi
callq 0xa240
jmp 0x6e5ab
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xa450
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringArray.cpp
// Function: str::getMaxWidth(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>>>>&)
int getMaxWidth(vector<string>& in)
{
	int out=0;
	
	for (int i=0; i<(int)in.size(); i++)
	{
		int w=getWidth(in[i]);
		
		if (w>out)
			out=w;
	}
	
	return out;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
shrq $0x5, %rdx
testl %edx, %edx
jle 0x6e6a9
pushq %rbp
pushq %r14
pushq %rbx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %eax, %eax
movq %rsi, %r9
shlq $0x5, %r9
movq 0x8(%rcx,%r9), %rdi
movl $0x0, %r8d
testl %edi, %edi
jle 0x6e695
addq %rcx, %r9
movq (%r9), %r9
movl %edi, %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
xorl %r8d, %r8d
xorl %r11d, %r11d
movslq %r11d, %r11
leaq 0x1(%r11), %rbx
cmpq %r10, %rbx
cmovleq %r10, %rbx
leaq -0x1(%rbx), %r14
cmpq %r11, %r14
je 0x6e68a
movb 0x1(%r9,%r11), %bpl
incq %r11
andb $-0x40, %bpl
negb %bpl
jo 0x6e672
jmp 0x6e68d
movq %rbx, %r11
incl %r8d
cmpl %edi, %r11d
jl 0x6e660
cmpl %eax, %r8d
cmovgl %r8d, %eax
incq %rsi
cmpq %rdx, %rsi
jne 0x6e634
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringArray.cpp
// Function: str::padWidths(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>>>>&, int, str::StringPadAlignment, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void padWidths(vector<string>& out, int size, StringPadAlignment alignment, string pad, string leftCap, string rightCap)
{
	if (size<0)
	{
		size=getMaxWidth(out);
	}
	
	for (int i=0; i<(int)out.size(); i++)
	{
		out[i]=str::pad(out[i], size, alignment, pad, leftCap, rightCap);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, %r12
movl %esi, 0x8(%rsp)
testl %esi, %esi
jns 0x6e6e7
movq %r12, %rdi
callq 0x6e610
movl %eax, 0x8(%rsp)
movq (%r12), %rbp
movq 0x8(%r12), %rax
subq %rbp, %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x6e823
xorl %r13d, %r13d
leaq 0x88(%rsp), %r15
xorl %ebx, %ebx
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xdde2
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xdde2
leaq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0xdde2
addq %r13, %rbp
movq %r14, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x48(%rsp), %r8
leaq 0x28(%rsp), %r9
callq 0x749c5
movq (%r12), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0xa370
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x6e7c5
callq 0xa2b0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x6e7d9
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6e7ed
callq 0xa2b0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x6e801
callq 0xa2b0
incq %rbx
movq (%r12), %rbp
movq 0x8(%r12), %rax
subq %rbp, %rax
shrq $0x5, %rax
cltq
addq $0x20, %r13
cmpq %rax, %rbx
jl 0x6e70c
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6e86a
movq %rax, %rbx
jmp 0x6e856
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x6e856
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6e86a
callq 0xa2b0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x6e87e
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringArray.cpp
// Function: str::join(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>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
string join(vector<string>& in, string joiner, bool addAtEnd)
{
	string out;
	
	for (int i=0; i<(int)in.size(); i++)
	{
		out+=in[i];
		
		if (addAtEnd || i!=(int)in.size()-1)
			out+=joiner;
	}
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
testl %ecx, %ecx
jle 0x6e922
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, %r13d
xorl %r12d, %r12d
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq 0xa110
testb %bpl, %bpl
jne 0x6e8f6
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x5, %rax
decl %eax
cmpq %rax, %r12
je 0x6e905
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa110
incq %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
movslq %ecx, %rcx
addq $0x20, %r13
cmpq %rcx, %r12
jl 0x6e8ce
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x6e945
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringDrawing.cpp
// Function: str::putStringInTreeNodeBox(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string putStringInTreeNodeBox(const string& in)
{
	vector<string> ary;
	splitByLine(ary, in);
	putArrayInTreeNodeBox(ary);
	return join(ary);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
movw $0xa, (%r14)
movq $0x1, -0x8(%r14)
leaq 0x38(%rsp), %rdx
xorl %ecx, %ecx
callq 0x747c0
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x7058c
callq 0xa2b0
movq %rsp, %rdi
callq 0x6fe6a
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x6984(%rip), %rsi      # 0x76f28
leaq 0x697e(%rip), %rdx      # 0x76f29
leaq 0x18(%rsp), %rdi
callq 0xdf6a
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x6e886
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x705d9
callq 0xa2b0
movq %rsp, %rdi
callq 0x148b4
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
jmp 0x70605
jmp 0x705f8
movq %rax, %rbx
jmp 0x7060f
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x7060f
callq 0xa2b0
movq %rsp, %rdi
callq 0x148b4
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringNumConversion.cpp
// Function: str::charToCppStringLiteralEscaped[abi:cxx11](unsigned char)
string charToCppStringLiteralEscaped(unsigned char c)
{
	string out="\\";
	
	for (int i=0; i<3; i++)
	{
		out+=c%8+'0';
		c/=8;
	}
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2ab0(%rip), %rsi      # 0x77152
leaq 0x2aaa(%rip), %rdx      # 0x77153
callq 0xdf6a
movl $0x3, %r14d
movl %ebp, %eax
andb $0x7, %al
orb $0x30, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0xa290
shrb $0x3, %bpl
decl %r14d
jne 0x746b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x746ec
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringNumConversion.cpp
// Function: str::intToBase62[abi:cxx11](unsigned int, int)
string intToBase62(unsigned int num, int maxDigits)
{
	int i=0;
	string out;
	
	while (num!=0 && (maxDigits<0 || i<maxDigits))
	{
		unsigned int digit=num%62;
		
		if (digit<10)
		{
			out+=(char)(digit+'0');
		}
		else if (digit<10+26)
		{
			out+=(char)(digit-10+'a');
		}
		else if (digit<10+26+26)
		{
			out+=(char)(digit-10-26+'A');
		}
		else
		{
			out+="_"; // this shouldn't happen
		}
		
		num/=62;
		i++;
	}
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
je 0x74785
movl %edx, %ebp
movl %esi, %r14d
xorl %r12d, %r12d
movl $0x84210843, %r13d      # imm = 0x84210843
testl %ebp, %ebp
sets %al
cmpl %ebp, %r12d
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x74785
movl %r14d, %r15d
shrl %r15d
imulq %r13, %r15
shrq $0x24, %r15
movl %r15d, %ecx
shll $0x6, %ecx
leal (%r15,%r15), %eax
subl %ecx, %eax
addl %r14d, %eax
cmpl $0x9, %eax
ja 0x74763
orb $0x30, %al
jmp 0x7476e
cmpl $0x23, %eax
ja 0x7476c
addb $0x57, %al
jmp 0x7476e
addb $0x1d, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa290
incl %r12d
cmpl $0x3d, %r14d
movl %r15d, %r14d
ja 0x7472b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x747a8
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/utils/stringUtils.cpp
// Function: str::getGlyphPosOf(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 getGlyphPosOf(const string& in, string pattern)
{
	int glyph=0;
	int byte=0;
	
	while (byte<(int)in.size())
	{
		if (subMatches(in, byte, pattern))
			return glyph;
		
		nextGlyph(byte, in);
		glyph++;
	}
	
	return -1;
}

// Assembly:
movq 0x8(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x759e3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdx
movl %ecx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
xorl %r9d, %r9d
testl %r9d, %r9d
js 0x759a6
movq 0x8(%rsi), %r10
movl %r9d, %r11d
leaq (%r10,%r11), %rbx
cmpq %rcx, %rbx
ja 0x759a6
testl %r10d, %r10d
setle %bl
jle 0x759a2
movq (%rsi), %rbx
movb (%rdx,%r11), %bpl
cmpb (%rbx), %bpl
jne 0x759a6
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
addq %rdx, %r11
movl $0x1, %r15d
movq %r15, %r14
cmpq %r15, %r10
je 0x7599c
movb (%r11,%r14), %bpl
leaq 0x1(%r14), %r15
cmpb (%rbx,%r14), %bpl
je 0x75986
cmpq %r10, %r14
setae %bl
testb %bl, %bl
jne 0x759e4
movslq %r9d, %r9
leaq 0x1(%r9), %r10
cmpq %rdi, %r10
cmovleq %rdi, %r10
leaq -0x1(%r10), %r11
cmpq %r9, %r11
je 0x759ce
movb 0x1(%rdx,%r9), %bl
incq %r9
andb $-0x40, %bl
negb %bl
jo 0x759b8
jmp 0x759d1
movq %r10, %r9
incl %r8d
cmpl %ecx, %r9d
jl 0x7594d
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %eax
jmp 0x759dd
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: initMatrix(Matrix*, int)
void initMatrix(Matrix* M, int dimension){
    M->dimension = dimension;
    M->matrix.resize(dimension);
    for (int i = 0; i < dimension; i++){
        M->matrix[i].resize(dimension);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
addq $0x8, %rbx
movslq %esi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7154
testl %r14d, %r14d
jle 0x24a6
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x71d6
addq $0x18, %r12
cmpq %r12, %r15
jne 0x248f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: printMatrix(Matrix&)
void printMatrix(Matrix& A){
    for (int i = 0; i < A.dimension; i ++){
        for (int j = 0; j < A.dimension; j++){
            cout << A.matrix[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jle 0x253e
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0xbb0c(%rip), %r14      # 0xdfd8
leaq 0x76af(%rip), %r15      # 0x9b82
cmpl $0x0, (%rbx)
jle 0x250c
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
callq 0x22a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
incq %rbp
movslq (%rbx), %rax
cmpq %rax, %rbp
jl 0x24de
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x24d3
movq 0xba93(%rip), %rbx      # 0xdfd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: isEqual(Matrix*, Matrix*)
bool isEqual(Matrix* A, Matrix* B){
    if (A->dimension != B->dimension) {
        return false;
    }
    else
    {
        for (int i = 0; i < A->dimension; ++i) {
            for (int j = 0; j < A->dimension; ++j) {
                if (A->matrix[i][j] != B->matrix[i][j]){
                    return false;
                }
            }
        }
        return true;
    }
}

// Assembly:
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0x25e6
testl %ecx, %ecx
setle %al
jle 0x25e8
pushq %rbp
pushq %rbx
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
leaq -0x1(%rcx), %rdi
xorl %r8d, %r8d
leaq (,%r8,8), %r9
leaq (%r9,%r9,2), %r10
movq (%rdx,%r10), %r9
movq (%rsi,%r10), %r10
movl (%r9), %r11d
cmpl (%r10), %r11d
jne 0x25e2
xorl %r11d, %r11d
cmpq %r11, %rdi
je 0x25d4
movl 0x4(%r9,%r11,4), %ebp
leaq 0x1(%r11), %rbx
cmpl 0x4(%r10,%r11,4), %ebp
movq %rbx, %r11
je 0x25b7
cmpq %rcx, %rbx
jb 0x25e2
incq %r8
cmpq %rcx, %r8
setae %al
cmpq %rcx, %r8
jne 0x2598
popq %rbx
popq %rbp
jmp 0x25e8
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: findOptDim(int, int)
int findOptDim(int n, int convThreshold){
    int counter = 0;
    while (n > convThreshold){
        if (n%2 == 0)
            n /= 2;
        else
            n = (n+1)/2;
        counter ++;
    }
    return n*pow(2,counter);
}

// Assembly:
movl %edi, %eax
xorl %edi, %edi
cmpl %esi, %eax
jle 0x2608
xorl %edi, %edi
movl %eax, %ecx
andl $0x1, %ecx
addl %eax, %ecx
sarl %ecx
incl %edi
movl %ecx, %eax
cmpl %esi, %ecx
jg 0x25f7
jmp 0x260a
movl %eax, %ecx
pushq %rax
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rsp)
movsd 0x69ec(%rip), %xmm0     # 0x9008
callq 0x2270
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: initPadding(Matrix*, int)
void initPadding(Matrix* M, int newdim){
    M->dimension = newdim;

    M->matrix.resize(newdim);
    for (int i = 0; i < newdim; i++){
        M->matrix[i].resize(newdim);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
addq $0x8, %rbx
movslq %esi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7154
testl %r14d, %r14d
jle 0x2676
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0x71d6
addq $0x18, %r12
cmpq %r12, %r15
jne 0x265f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: convMult(Matrix*, Matrix*, Matrix*, int, int, int, int, int, int, int)
void convMult(Matrix* A, Matrix* B, Matrix* C, int topA, int leftA, int topB, int leftB, int topC, int leftC, int dimension) {
    for (int i = 0; i < dimension; ++i)
		for (int k = 0; k < dimension; ++k)
			for (int j = 0; j < dimension; ++j)
                if (k == 0) 
                    C->matrix[topC + i][leftC + j] = A->matrix[topA + i][leftA + k] * B->matrix[topB + k][leftB + j]; 
				else
                    C->matrix[topC + i][leftC + j] += A->matrix[topA + i][leftA + k] * B->matrix[topB + k][leftB + j];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x50(%rsp), %r10d
testl %r10d, %r10d
jle 0x2942
movslq %r8d, %rax
movslq %r9d, %r8
movslq 0x38(%rsp), %r9
movq %r9, -0x10(%rsp)
movslq 0x48(%rsp), %r9
movq %r9, -0x18(%rsp)
movslq %ecx, %rcx
movslq 0x40(%rsp), %r9
movl %r10d, %r10d
xorl %r15d, %r15d
leaq (%rcx,%rcx,2), %r11
leaq (%r8,%r8,2), %rbx
movq %r10, %r8
leaq (%r9,%r9,2), %r14
movq %r10, -0x20(%rsp)
movq %r15, -0x28(%rsp)
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,2), %r15
xorl %r12d, %r12d
leaq (,%r12,4), %rcx
movq %rcx, -0x8(%rsp)
leaq (%r12,%r12,2), %rbp
shlq $0x3, %rbp
movq %r8, %rcx
movq -0x10(%rsp), %r8
movq -0x18(%rsp), %r9
testq %r12, %r12
je 0x28e8
movq 0x8(%rdi), %r10
addq %r15, %r10
movq (%r10,%r11,8), %r10
addq -0x8(%rsp), %r10
movq 0x8(%rsi), %r13
addq %rbp, %r13
movq (%r13,%rbx,8), %r13
movl (%r13,%r8,4), %r13d
imull (%r10,%rax,4), %r13d
movq 0x8(%rdx), %r10
addq %r15, %r10
movq (%r10,%r14,8), %r10
addl %r13d, (%r10,%r9,4)
jmp 0x2915
movq 0x8(%rdi), %r10
addq %r15, %r10
movq (%r10,%r11,8), %r10
movq 0x8(%rsi), %r13
movq (%r13,%rbx,8), %r13
movl (%r13,%r8,4), %r13d
imull (%r10,%rax,4), %r13d
movq 0x8(%rdx), %r10
addq %r15, %r10
movq (%r10,%r14,8), %r10
movl %r13d, (%r10,%r9,4)
incq %r9
incq %r8
decq %rcx
jne 0x28ac
incq %r12
movq -0x20(%rsp), %r8
cmpq %r8, %r12
jne 0x288a
movq -0x28(%rsp), %r15
incq %r15
cmpq %r8, %r15
jne 0x2876
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: multiply(Matrix*, Matrix*, Matrix*, int, int, int, int, int, int, int)
void multiply(Matrix* A, Matrix* B, Matrix* C, int topA, int leftA, int topB, int leftB, int topC, int leftC, int dimension){
    if (dimension > convThreshold) {
        if (dimension > threadThresh)
            strassenMultThread(A, B, C, topA, leftA, topB, leftB, topC, leftC, dimension);
        else
            strassenMult(A, B, C, topA, leftA, topB, leftB, topC, leftC, dimension);
        
    }
    else
        convMult(A, B, C, topA, leftA, topB, leftB, topC, leftC, dimension);
}

// Assembly:
pushq %rbx
movl 0x28(%rsp), %ebx
cmpl %ebx, 0xb2de(%rip)      # 0xe1a0
jge 0x2ee7
movl 0x20(%rsp), %r11d
movl 0x18(%rsp), %r10d
movl 0x10(%rsp), %eax
cmpl %ebx, 0xb2c4(%rip)      # 0xe19c
jge 0x2eed
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x2efe
jmp 0x2ef8
popq %rbx
jmp 0x2822
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x294d
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: multiply(Matrix*, Matrix*)
Matrix* multiply(Matrix* A, Matrix* B){
    if (A->dimension != B->dimension)
        return NULL;
    int dimension = A->dimension;
    Matrix* C = new Matrix();
    initMatrix(C, A->dimension);
    
    int padding = findOptDim(dimension, convThreshold);
    initPadding(A, padding);
    initPadding(B, padding);
    initPadding(C, padding);
    multiply(A,B,C,0,0,0,0,0,0,padding);
    
    removePadding(A, dimension);
    removePadding(B, dimension);
    removePadding(C, dimension);
    return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %ebx
xorl %r13d, %r13d
cmpl (%rsi), %ebx
jne 0x39cd
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x21b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, %rdi
movl %ebx, %esi
callq 0x245c
movl 0xa87a(%rip), %eax      # 0xe1a0
movl %ebx, %ecx
cmpl %eax, %ebx
jle 0x3943
xorl %r13d, %r13d
movl %ebx, %edx
movl %ebx, %ecx
andl $0x1, %ecx
addl %edx, %ecx
sarl %ecx
incl %r13d
movl %ecx, %edx
cmpl %eax, %ecx
jg 0x3933
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x56b0(%rip), %xmm0     # 0x9008
movl %r13d, %edi
callq 0x2270
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x262c
movq %r15, %rdi
movl %r13d, %esi
callq 0x262c
movq %r14, %rdi
movl %r13d, %esi
callq 0x262c
xorl %eax, %eax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r13
pushq %rax
pushq %rax
pushq %rax
callq 0x2eb7
addq $0x20, %rsp
movq %r12, %rdi
movl %ebx, %esi
callq 0x267f
movq %r15, %rdi
movl %ebx, %esi
callq 0x267f
movq %r14, %rdi
movl %ebx, %esi
callq 0x267f
jmp 0x39d0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: populateRandomMatrix(Matrix*, int, int)
void populateRandomMatrix(Matrix* M, int low, int high){
    random_device r;
    mt19937 mtgen(r());
    uniform_int_distribution<> dist(low,high);
    for (int i = 0; i < M->dimension; i++)
        for (int j = 0; j < M->dimension; j++)
            M->matrix[i][j] = dist(mtgen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x1390(%rsp), %r15
movq %r15, %rdi
callq 0x7b54
movq %r15, %rdi
callq 0x21e0
movl %eax, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x8(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x3a1e
movq $0x270, 0x1388(%rsp) # imm = 0x270
movl %r14d, (%rsp)
movl %ebp, 0x4(%rsp)
cmpl $0x0, (%rbx)
jle 0x3a9e
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq %rsp, %r15
cmpl $0x0, (%rbx)
jle 0x3a93
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x803e
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movl %eax, (%rcx,%rbp,4)
incq %rbp
movslq (%rbx), %rax
cmpq %rax, %rbp
jl 0x3a6f
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x3a64
leaq 0x1390(%rsp), %rdi
callq 0x2180
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ad9
jmp 0x3ac1
movq %rax, %rbx
leaq 0x1390(%rsp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x7c3b
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: findOptimalconvThreshold()
void findOptimalconvThreshold() {

    for (convThreshold = 8; convThreshold <= 256; convThreshold*=2){
    //for (convThreshold = 2; convThreshold <= 64; convThreshold++){    

        
        
        double total = 0;
        //cout << "multiplying matrices, n = " << i << endl;
        for (int j = 0; j < 5; j ++){
            Matrix* m1 = new Matrix();
            Matrix* m2 = new Matrix();
            initMatrix(m1, 256);
            initMatrix(m2, 256);
            //cout << "populating m1" << endl;
            populateRandomMatrix(m1, 0, 1);
            //cout << "populating m2" << endl;
            populateRandomMatrix(m2, 0, 1);
            clock_t start;
            start = clock();
            
            Matrix* m3 = multiply(m1, m2);
            total += (std::clock() - start) / (double)(CLOCKS_PER_SEC);
            delete(m1);
            delete(m2);
            delete(m3);
        }

        cout << convThreshold << "\t" << total / 5 << endl;

        //cout << "finished multiplying.\n" << endl;
        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x8, 0xa6a7(%rip)      # 0xe1a0
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x21b0
movq %rax, %r15
leaq 0x8(%rax), %r13
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
movl $0x20, %edi
callq 0x21b0
movq %rax, %r12
addq $0x8, %rax
movq %rax, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%r12)
movapd %xmm0, 0x10(%r12)
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x245c
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x245c
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x39e1
movq %r12, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x39e1
callq 0x2110
movq %rax, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x38df
movq %rax, %rbx
callq 0x2110
subq %r14, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x5461(%rip), %xmm0     # 0x9010
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0x7bfc
movq %r15, %rdi
callq 0x2190
movq 0x10(%rsp), %rdi
callq 0x7bfc
movq %r12, %rdi
callq 0x2190
testq %rbx, %rbx
je 0x3bf0
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x7bfc
movq %rbx, %rdi
callq 0x2190
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
incl %ebp
cmpl $0x5, %ebp
jne 0x3aff
movl 0xa594(%rip), %esi      # 0xe1a0
movq 0xa3c5(%rip), %rdi      # 0xdfd8
movsd %xmm0, (%rsp)
callq 0x22a0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x5e51(%rip), %rsi      # 0x9a80
callq 0x21c0
movsd (%rsp), %xmm0
mulsd 0x53d7(%rip), %xmm0     # 0x9018
movq %rbx, %rdi
callq 0x2240
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movl 0xa527(%rip), %eax      # 0xe1a0
leal (%rax,%rax), %ecx
movl %ecx, 0xa51e(%rip)      # 0xe1a0
xorpd %xmm0, %xmm0
movl $0x0, %ebp
cmpl $0x80, %eax
jle 0x3aff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: timeRandMult(int)
double timeRandMult(int dimension){
            Matrix* m1 = new Matrix();
            Matrix* m2 = new Matrix();
            initMatrix(m1, dimension);
            initMatrix(m2, dimension);
            populateRandomMatrix(m1, 0, 1);
            populateRandomMatrix(m2, 0, 1);
            clock_t start;
            start = clock();
            Matrix* m3 = multiply(m1, m2);
            delete(m1);
            delete(m2);
            delete(m3);
            return (std::clock() - start) / (double)(CLOCKS_PER_SEC);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x20, %edi
callq 0x21b0
movq %rax, %rbx
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movl $0x20, %edi
callq 0x21b0
movq %rax, %r14
leaq 0x8(%rax), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x245c
movq %r14, %rdi
movl %ebp, %esi
callq 0x245c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x39e1
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x39e1
callq 0x2110
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38df
movq %rax, %rbp
movq %r15, %rdi
callq 0x7bfc
movq %rbx, %rdi
callq 0x2190
movq %r12, %rdi
callq 0x7bfc
movq %r14, %rdi
callq 0x2190
testq %rbp, %rbp
je 0x3d69
movq %rbp, %rdi
addq $0x8, %rdi
callq 0x7bfc
movq %rbp, %rdi
callq 0x2190
callq 0x2110
subq %r13, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x528f(%rip), %xmm0     # 0x9010
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: findOptimalThreadThresh()
void findOptimalThreadThresh() {
    convThreshold = 32;
    threadThresh = 64;
    while (threadThresh != 4096){
        //cout << threadThresh << endl;;
        
        
        double total = 0;
        //cout << "multiplying matrices, n = " << i << endl;
        for (int j = 0; j < 1; j ++){
            total += timeRandMult(2048);
        }
        cout << threadThresh << "\t" << total / 1 << endl;
        //cout << "finished multiplying.\n" << endl;
        threadThresh *= 2;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x20, 0xa3fd(%rip)     # 0xe1a0
movl $0x40, 0xa3ef(%rip)     # 0xe19c
movq 0xa224(%rip), %rbx      # 0xdfd8
leaq 0x5cc5(%rip), %r14      # 0x9a80
movl $0x800, %edi            # imm = 0x800
callq 0x3ca5
movsd %xmm0, 0x8(%rsp)
movl 0xa3cb(%rip), %esi      # 0xe19c
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movl 0xa372(%rip), %eax      # 0xe19c
leal (%rax,%rax), %ecx
movl %ecx, 0xa369(%rip)      # 0xe19c
cmpl $0x800, %eax            # imm = 0x800
jne 0x3dbb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: testRandMatrix()
void testRandMatrix(){
    Matrix* m = new Matrix();
    initMatrix(m,10);
    populateRandomMatrix(m, 0,1);
    printMatrix(*m);
    free(m);
}

// Assembly:
pushq %rbx
movl $0x20, %edi
callq 0x21b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, %rdi
movl $0xa, %esi
callq 0x245c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x39e1
movq %rbx, %rdi
callq 0x24af
movq %rbx, %rdi
popq %rbx
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: testInitMatrix()
void testInitMatrix(){
    Matrix* m = new Matrix();
    initMatrix(m,3);
    printMatrix(*m);
    free(m);
}

// Assembly:
pushq %rbx
movl $0x20, %edi
callq 0x21b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, %rdi
movl $0x3, %esi
callq 0x245c
movq %rbx, %rdi
callq 0x24af
movq %rbx, %rdi
popq %rbx
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: testPowers2()
void testPowers2(){
    for (int i = 2; i <= 4096; i *= 2){
        Matrix* m1 = new Matrix();
        initMatrix(m1, i);
        Matrix* m2 = new Matrix();
        initMatrix(m2, i);
        //cout << "populating m1" << endl;
        populateRandomMatrix(m1, -10, 10);
        //cout << "populating m2" << endl;
        populateRandomMatrix(m2, -10, 10);
        
        //cout << "multiplying matrices, n = " << i << endl;
        clock_t start;
        start = clock();
        Matrix* m3 = multiply(m1, m2);
        

        cout << "multiplied " << i << "x" << i << " in " << ((double) (clock() - start) / (double)(CLOCKS_PER_SEC)) << "s" << endl;
        delete(m1);
        delete(m2);
        delete(m3);

    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x2, %ebx
movl $0x20, %edi
callq 0x21b0
movq %rax, %r15
addq $0x8, %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movq %r15, %rdi
movl %ebx, %esi
callq 0x245c
movl $0x20, %edi
callq 0x21b0
movq %rax, %r13
addq $0x8, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movaps %xmm0, 0x10(%r13)
movq %r13, %rdi
movl %ebx, %esi
callq 0x245c
movq %r15, %rdi
movl $0xfffffff6, %esi       # imm = 0xFFFFFFF6
movl $0xa, %edx
callq 0x39e1
movq %r13, %rdi
movl $0xfffffff6, %esi       # imm = 0xFFFFFFF6
movl $0xa, %edx
callq 0x39e1
callq 0x2110
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x38df
movq %rax, %r14
movl $0xb, %edx
movq 0x7663(%rip), %rbp      # 0xdfd8
movq %rbp, %rdi
leaq 0x31f9(%rip), %rsi      # 0x9b78
callq 0x21c0
movq %rbp, %rdi
movl %ebx, %esi
callq 0x22a0
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x31e4(%rip), %rsi      # 0x9b84
callq 0x21c0
movq %rbp, %rdi
movl %ebx, %esi
callq 0x22a0
movq %rax, %rbp
movl $0x4, %edx
movq %rax, %rdi
leaq 0x31c5(%rip), %rsi      # 0x9b86
callq 0x21c0
callq 0x2110
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x2632(%rip), %xmm0     # 0x9010
movq %rbp, %rdi
callq 0x2240
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x317e(%rip), %rsi      # 0x9b76
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq 0x10(%rsp), %rdi
callq 0x7bfc
movq %r15, %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
callq 0x7bfc
movq %r13, %rdi
callq 0x2190
testq %r14, %r14
je 0x6a62
movq %r14, %rdi
addq $0x8, %rdi
callq 0x7bfc
movq %r14, %rdi
callq 0x2190
leal (%rbx,%rbx), %eax
cmpl $0x801, %ebx            # imm = 0x801
movl %eax, %ebx
jb 0x68d6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aronszanto[P]strassen/main.cpp
// Function: FileToMatrix(char*, int, int)
Matrix* FileToMatrix(char* inputfile, int dimension, int order){
    Matrix* M = new Matrix();
    initMatrix(M, dimension);

    ifstream inFile(inputfile);
    string line;
    for (int i = 0; i < pow(dimension,2)*order; ++i)
    {
        getline(inFile, line);
    }

    for (int i = 0; i < dimension; ++i)
    {
        for (int j = 0; j < dimension; ++j)
        {
            getline(inFile, line);
            M->matrix[i][j] = stoi(line);
        }
    }
    inFile.close();
    return M;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r12
movl $0x20, %edi
callq 0x21b0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movl %ebp, %esi
callq 0x245c
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x22d0
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movb $0x0, (%rax)
mulsd %xmm0, %xmm0
cvtsi2sd %r15d, %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jbe 0x6b4c
movl $0x1, %ebx
leaq 0x18(%rsp), %r15
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22e0
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
incl %ebx
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x6b14
testl %ebp, %ebp
jle 0x6c10
movl %ebp, %eax
movq %rax, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq (%rax,%rax,2), %r12
xorl %ebx, %ebx
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %edx
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
callq 0x22e0
movq 0x18(%rsp), %rbp
callq 0x2040
movq %rax, %r13
movl (%rax), %r15d
movl $0x0, (%rax)
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
movl $0xa, %edx
callq 0x21f0
cmpq %rbp, 0x38(%rsp)
je 0x6c4f
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6c5b
movl (%r13), %ecx
cmpl $0x22, %ecx
je 0x6c5b
testl %ecx, %ecx
jne 0x6be1
movl %r15d, (%r13)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, (%rcx,%rbx,4)
incq %rbx
cmpq %rbx, (%rsp)
jne 0x6b67
movq 0x10(%rsp), %rax
incq %rax
cmpq (%rsp), %rax
jne 0x6b5c
leaq 0x40(%rsp), %rdi
callq 0x2060
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6c2e
callq 0x2190
leaq 0x40(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f74(%rip), %rdi      # 0x9bca
callq 0x20f0
leaq 0x2f68(%rip), %rdi      # 0x9bca
callq 0x2200
jmp 0x6c6b
jmp 0x6c6b
movq %rax, %rbx
jmp 0x6c7e
movq %rax, %rbx
cmpl $0x0, (%r13)
jne 0x6c7e
movl %r15d, (%r13)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6c92
callq 0x2190
leaq 0x40(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/justinpajak[P]Sum_SGX/aggsum.cpp
// Function: readAndDecrypt(std::vector<float, std::allocator<float>>&)
void readAndDecrypt(vector<float>& nums) {
	int enc_data = open("enc.txt", O_RDONLY);
	if (!enc_data) {
		fprintf(stderr, "Unable to open file: %s\n", strerror(errno));
		return;
	}
	unsigned char ciphertext[128];
	unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
    unsigned char *iv = (unsigned char *)"0123456789012345";
	while(read(enc_data, (char*)ciphertext, 128)) {
		unsigned char plaintext[128];
		int plaintext_len = decrypt(ciphertext, 32, key, iv, plaintext);
		plaintext[plaintext_len] = '\0';
		nums.push_back(atof((const char*)plaintext));
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0xa56(%rip), %rdi       # 0x2023
xorl %esi, %esi
xorl %eax, %eax
callq 0x1100
testl %eax, %eax
je 0x1692
movl %eax, %r14d
leaq -0x130(%rbp), %rsi
movl $0x80, %edx
movl %eax, %edi
callq 0x11a0
testq %rax, %rax
je 0x1680
leaq 0xa61(%rip), %r12       # 0x2065
leaq -0x130(%rbp), %r13
leaq -0xb0(%rbp), %r15
movq %r13, %rdi
movl $0x20, %esi
leaq 0xa23(%rip), %rdx       # 0x2044
movq %r12, %rcx
movq %r15, %r8
callq 0x16cb
cltq
movb $0x0, -0xb0(%rbp,%rax)
movq %r15, %rdi
callq 0x1180
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x165f
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x166b
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x17f4
movl $0x80, %edx
movl %r14d, %edi
movq %r13, %rsi
callq 0x11a0
testq %rax, %rax
jne 0x1612
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1210
jmp 0x1680
// File: /workspace/github_cpp_makefile_star2_O1/justinpajak[P]Sum_SGX/aggsum.cpp
// Function: agg_sum(std::vector<float, std::allocator<float>>)
double agg_sum(vector<float> nums) {
	double sum;
	for (int i = 0; i < nums.size(); i++) {
		sum += nums[i];
	}
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtss2sd (%rax,%rdx,4), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x16b5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::decompress_t::pop_vlq_uint(unsigned char const*&, unsigned char const*, unsigned long&)
bool pop_vlq_uint(const unsigned char*& i, const unsigned char* e, size_t& res) {

        while (1) {

            if (i == e)
                return false;

            size_t c = *i;

            if ((c & 0x80) == 0) {
                state.vlq_num |= (c << state.vlq_off);
                break;
            }

            state.vlq_num |= ((c & 0x7F) << state.vlq_off);
            state.vlq_off += 7;
            ++i;
        }

        res = state.vlq_num;
        state.vlq_num = 0;
        state.vlq_off = 0;

        return true;
    }

// Assembly:
movq %rcx, %rax
movq (%rsi), %r11
movq 0x50(%rdi), %r9
movq 0x58(%rdi), %rcx
movq %r11, %r8
cmpq %rdx, %r11
je 0x3626
movzbl (%r8), %r10d
testb %r10b, %r10b
js 0x35f3
movq %r10, %r11
shlq %cl, %r11
orq %r11, %r9
movq %r9, 0x50(%rdi)
movq %r8, %r11
jmp 0x3613
movl %r10d, %r11d
andl $0x7f, %r11d
shlq %cl, %r11
orq %r11, %r9
movq %r9, 0x50(%rdi)
addq $0x7, %rcx
movq %rcx, 0x58(%rdi)
leaq 0x1(%r8), %r11
movq %r11, (%rsi)
testb %r10b, %r10b
js 0x35d0
movq 0x50(%rdi), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
cmpq %rdx, %r8
setne %al
retq
nop