LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::addVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, IMath*)
void addVar(std::string *leftValue, IMath *rightVar){
		varEqualsMathMapping[*leftValue] = rightVar;

		if(ownerBlock == NULL)
			scheduledVariableRegister = true;
		else
			ownerBlock->registerLocalVariable(generateVariable(&type, leftValue), myLine);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x80, %rdi
callq 0xe2ca
movq %r15, (%rax)
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xa75b
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x803e
movl 0x8(%rbx), %edx
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xdc30
movb $0x1, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IMath.hpp
// Function: IMath::isInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static bool isInteger(std::string numberStr){
		if(isNumber(numberStr)){
			if(numberStr.find(".") != std::string::npos || numberStr.find("e") != std::string::npos ||
					numberStr.find("E") != std::string::npos)
				return false;

			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfbae
movq %r14, %rdi
callq 0xa194
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa86d
callq 0x7350
testb %r14b, %r14b
je 0xa8d0
leaq 0x24ed2(%rip), %rsi     # 0x2f74b
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7790
cmpq $-0x1, %rax
jne 0xa8d3
leaq 0x20a45(%rip), %rsi     # 0x2b2dd
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7790
cmpq $-0x1, %rax
jne 0xa8d3
leaq 0x20861(%rip), %rsi     # 0x2b118
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7790
cmpq $-0x1, %rax
sete %r14b
jmp 0xa8d3
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa8f2
callq 0x7350
movq %rbx, %rdi
callq 0x77b0
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IAssignment.hpp
// Function: IAssignment::IAssignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, int)
IAssignment(std::string* leftVariableId, int value, int myline) : IStatement(myline){
	  this->leftVariableId = new std::string(*leftVariableId);
	  rightValueInt = value;
	  rightIsValue = true;
	  rightIsInteger = true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq $0x0, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
leaq 0x307b1(%rip), %rax     # 0x3b0d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x24(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movl $0x0, 0x58(%rdi)
movl $0x20, %edi
callq 0x7390
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xfbae
movq %r15, 0x48(%r14)
movl %ebx, 0x30(%r14)
movw $0x101, 0x58(%r14)      # imm = 0x101
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7350
movq %rbx, %rdi
callq 0x77b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IFlowControl.hpp
// Function: IFlowControl::addElseSingleStatement(IStatement*)
void addElseSingleStatement(IStatement *stmt){
		if(elseBlock == NULL && stmt != NULL){
			elseBlock = new IBlock();
			elseBlock->addStatement(stmt);
			stmt->setOwnerBlock(elseBlock);
			elseBlock->setStatementOwner(this);
		}
	}

// Assembly:
testq %rsi, %rsi
je 0xab52
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0xab4e
movq %rsi, %r14
movl $0x40, %edi
callq 0x7390
leaq 0x304e0(%rip), %rcx     # 0x3aff0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, 0x28(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xa466
movq 0x28(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x28(%rbx), %rax
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IFlowControl.hpp
// Function: IFlowControl::addIfSingleStatement(IStatement*)
void addIfSingleStatement(IStatement *stmt){
		if(ifBlock == NULL && stmt != NULL){
			ifBlock = new IBlock();
			ifBlock->addStatement(stmt);
			stmt->setOwnerBlock(ifBlock);
			ifBlock->setStatementOwner(this);
		}
	}

// Assembly:
testq %rsi, %rsi
je 0xabc0
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xabbc
movq %rsi, %r14
movl $0x40, %edi
callq 0x7390
leaq 0x30472(%rip), %rcx     # 0x3aff0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, 0x20(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xa466
movq 0x20(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IWhile.hpp
// Function: IWhile::addSingleStatement(IStatement*)
void addSingleStatement(IStatement *stmt) {
		if (innerBlock == NULL && stmt != NULL) {
			innerBlock = new IBlock();
			innerBlock->addStatement(stmt);
			stmt->setOwnerBlock(innerBlock);
			innerBlock->setStatementOwner(this);
		}
	}

// Assembly:
testq %rsi, %rsi
je 0xac2e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xac2a
movq %rsi, %r14
movl $0x40, %edi
callq 0x7390
leaq 0x30404(%rip), %rcx     # 0x3aff0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, 0x20(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xa466
movq 0x20(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IRepeat.hpp
// Function: IRepeat::addSingleStatement(IStatement*)
void addSingleStatement(IStatement *stmt){
		if(innerBlock == NULL && stmt != NULL){
			innerBlock = new IBlock();
			innerBlock->addStatement(stmt);
			stmt->setOwnerBlock(innerBlock);
			innerBlock->setStatementOwner(this);
		}
	}

// Assembly:
testq %rsi, %rsi
je 0xae62
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0xae5e
movq %rsi, %r14
movl $0x40, %edi
callq 0x7390
leaq 0x301d0(%rip), %rcx     # 0x3aff0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, 0x28(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xa466
movq 0x28(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x28(%rbx), %rax
movq %rbx, 0x38(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::createCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool createCode(std::string tempFile){
		std::fstream output(tempFile, std::ios::out);

		try{
			if(output){
				output << "#include <iostream>\n";
				output << "using namespace std;\n";
				output << "int main(){\n";
				generateCode(output);
				output << "return 0; }";
				output.close();

				return true;
			}else{
				std::cout << "Erro ao abrir arquivo fonte" << tempFile << std::endl;
				return false;
			}
		}catch(ISourceErrorException& exception){
			std::cout << exception.getErrorMessage() << std::endl;
			output.close();

			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x248(%rbp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x7740
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0xaef8
movq 0x31122(%rip), %rdi     # 0x3bfc8
leaq 0x24a12(%rip), %rsi     # 0x2f8bf
movl $0x1b, %edx
callq 0x7460
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x31103(%rip), %rdi     # 0x3bfc8
callq 0x7460
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x72b0
xorl %ebx, %ebx
jmp 0xaf6c
leaq -0x238(%rbp), %r14
leaq 0x24975(%rip), %rsi     # 0x2f87b
movl $0x14, %edx
movq %r14, %rdi
callq 0x7460
leaq 0x24976(%rip), %rsi     # 0x2f890
movl $0x15, %edx
movq %r14, %rdi
callq 0x7460
leaq 0x24978(%rip), %rsi     # 0x2f8a6
movl $0xc, %edx
movq %r14, %rdi
callq 0x7460
movq (%rbx), %rax
leaq -0x248(%rbp), %rsi
movq %rbx, %rdi
callq *(%rax)
leaq 0x24962(%rip), %rsi     # 0x2f8b3
movl $0xb, %edx
movq %r14, %rdi
callq 0x7460
movb $0x1, %bl
leaq -0x248(%rbp), %rdi
callq 0x7070
leaq -0x248(%rbp), %rdi
callq 0x7890
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xb00e
movq %rbx, %rdi
callq 0x7190
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x27ff4
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x31015(%rip), %rdi     # 0x3bfc8
callq 0x7460
movq %rax, %rdi
callq 0x71e0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafd2
callq 0x7350
leaq -0x248(%rbp), %rdi
callq 0x7070
callq 0x7700
jmp 0xaef4
movq %rax, %rbx
jmp 0xb00e
jmp 0xafef
movq %rax, %rbx
jmp 0xb009
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb009
callq 0x7350
callq 0x7700
leaq -0x248(%rbp), %rdi
callq 0x7890
movq %rbx, %rdi
callq 0x77b0
movq %rax, %rdi
callq 0xb2be
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IDefinition.hpp
// Function: IDefinition::getCppType[abi:cxx11]()
std::string getCppType() {
		if(type == "inteiro")
			return "int";
		else if(type == "real")
			return "double";
		else if(type == "string")
			return "std::string";
		else{
			std::string errorMsg = "Tipo de variavel mal definido.";
			throw ISourceErrorException(errorMsg, myLine);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %r15
leaq 0x1e447(%rip), %rsi     # 0x2ac2b
movq %r15, %rdi
callq 0x7100
testl %eax, %eax
je 0xc82d
leaq 0x1e42f(%rip), %rsi     # 0x2ac26
movq %r15, %rdi
callq 0x7100
testl %eax, %eax
je 0xc844
leaq 0x1eada(%rip), %rsi     # 0x2b2e4
movq %r15, %rdi
callq 0x7100
testl %eax, %eax
jne 0xc873
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1eabb(%rip), %rsi     # 0x2b2df
leaq 0x1eabf(%rip), %rdx     # 0x2b2ea
jmp 0xc859
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1ea99(%rip), %rsi     # 0x2b2d4
leaq 0x1ea95(%rip), %rdx     # 0x2b2d7
jmp 0xc859
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1ea86(%rip), %rsi     # 0x2b2d8
leaq 0x1ea85(%rip), %rdx     # 0x2b2de
movq %rbx, %rdi
callq 0x1c46a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1ea68(%rip), %rsi     # 0x2b2eb
leaq 0x1ea7f(%rip), %rdx     # 0x2b309
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x1c46a
movl $0x28, %edi
callq 0x71f0
movq %rax, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xfbae
movl 0x8(%r14), %edx
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xcad6
xorl %r15d, %r15d
leaq 0x2e7d5(%rip), %rsi     # 0x3b0b0
leaq 0x244(%rip), %rdx       # 0xcb26
movq %rbx, %rdi
callq 0x7770
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc8fb
callq 0x7350
testb %r15b, %r15b
jne 0xc905
jmp 0xc90d
movq %rax, %r14
movq %rbx, %rdi
callq 0x72e0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xc91b
callq 0x7350
movq %r14, %rdi
callq 0x77b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::getLocalVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
IData* getLocalVariable(std::string variableId){
		for(ulong i = 0; i < blockVariables.size(); i++){

			if(blockVariables[i]->getId() == variableId)
				return blockVariables[i];
		}

		/* Caso o bloco local não possua a variavel, perguntamos aos blocos pai */
		if(stmtOwner != NULL){
			return stmtOwner->getOwnerBlock()->getLocalVariable(variableId);
		}

		return NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0xc9cb
xorl %r13d, %r13d
movq (%rax,%r13,8), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xfbae
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xc992
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0xc99b
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x73e0
testl %eax, %eax
sete %r15b
jmp 0xc99e
movq -0x48(%rbp), %r12
xorl %r15d, %r15d
jmp 0xc99e
movb $0x1, %r15b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0xc9af
movq %r12, %rdi
callq 0x7350
testb %r15b, %r15b
jne 0xca14
incq %r13
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0xc94c
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xca1e
movq 0x10(%rax), %r14
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0xfbae
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc924
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xca20
callq 0x7350
jmp 0xca20
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rbx
jmp 0xca20
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xca43
callq 0x7350
movq %rbx, %rdi
callq 0x77b0
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::registerLocalVariable(IData*, int)
void registerLocalVariable(IData* var, int myLine) {
		if(getLocalVariable(var->getId()) != NULL){
			std::string errorMsg = "Variavel referenciada ja existente.";
			throw ISourceErrorException(errorMsg, myLine);
		}
		blockVariables.push_back(var);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %r12
movq %r12, %rdi
callq 0xfbae
movq %r14, %rdi
movq %r12, %rsi
callq 0xc924
movq %rax, %r12
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0xdc8e
callq 0x7350
testq %r12, %r12
jne 0xdcc6
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0xdca7
movq %r15, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0xdcb7
addq $0x8, %r14
leaq -0x30(%rbp), %rdx
movq %r14, %rdi
callq 0xdd88
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d9bd(%rip), %rsi     # 0x2b692
leaq 0x1d9d9(%rip), %rdx     # 0x2b6b5
leaq -0x50(%rbp), %rdi
callq 0x1c46a
movl $0x28, %edi
callq 0x71f0
movq %rax, %r14
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0xfbae
movb $0x1, %r13b
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0xcad6
xorl %r13d, %r13d
leaq 0x2d386(%rip), %rsi     # 0x3b0b0
leaq -0x120b(%rip), %rdx     # 0xcb26
movq %r14, %rdi
callq 0x7770
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0xdd4a
callq 0x7350
testb %r13b, %r13b
jne 0xdd54
jmp 0xdd5c
movq %rax, %rbx
movq %r14, %rdi
callq 0x72e0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0xdd7b
jmp 0xdd80
movq %rax, %rbx
jmp 0xdd80
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0xdd80
callq 0x7350
movq %rbx, %rdi
callq 0x77b0
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IAssignment.hpp
// Function: IAssignment::~IAssignment()
virtual ~IAssignment(){
	  delete leftVariable;
	  delete rightVariable;
	  delete rightStrValue;
	  delete rightVariableMath;
	  delete leftVariableId;
	  delete rightVariableId;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2b80f(%rip), %rax     # 0x3b0d0
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xf8d3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf8e2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xf8fc
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xf8fc
callq 0x7350
movq %r14, %rdi
callq 0x7350
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0xf927
leaq 0x20(%r14), %rdi
callq 0xe272
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xf927
callq 0x7350
movq %r14, %rdi
callq 0x7350
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0xf949
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xf949
callq 0x7350
movq %r14, %rdi
callq 0x7350
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0xf96b
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0xf96b
callq 0x7350
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7350
nop
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IBlock.hpp
// Function: IBlock::generateRandomVariableName[abi:cxx11](unsigned long)
static std::string generateRandomVariableName( size_t length )
	{
	    auto randchar = []() -> char
	    {
	        const char charset[] =
	        "0123456789"
	        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	        "abcdefghijklmnopqrstuvwxyz";
	        const size_t max_index = (sizeof(charset) - 1);
	        return charset[ rand() % max_index ];
	    };
	    std::string str(length,0);
	    std::generate_n( str.begin(), length, randchar );
	    return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rdi, -0x30(%rbp)
xorl %edx, %edx
callq 0x7490
testq %r14, %r14
je 0x276b1
movq -0x30(%rbp), %rax
movq (%rax), %r15
xorl %r12d, %r12d
movabsq $-0x7bdef7bdef7bdef7, %r13 # imm = 0x8421084210842109
leaq 0x8973(%rip), %rbx      # 0x2fff0
callq 0x70e0
movslq %eax, %rcx
movq %rcx, %rax
shrq %rax
mulq %r13
shrq $0x4, %rdx
movq %rdx, %rax
shlq $0x6, %rax
addq %rdx, %rdx
subq %rax, %rdx
addq %rcx, %rdx
movb (%rbx,%rdx), %al
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x2767d
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/araujoigor[P]ipp-compiler/./src/include/IRead.hpp
// Function: IRead::generateCode(std::basic_fstream<char, std::char_traits<char>>&)
void generateCode(std::fstream& fileStream) {

		/* Um leia é representado por um cin */
		fileStream << "cin >> ";

		/* Obtemos a variável especificada, a partir dos blocos "pai" */
		IData *data = ownerBlock->getLocalVariable(varId);

		/* Se a variável não existir, geramos um erro. */
		 if(data == NULL){
			 std::string errorMsg = "Variavel \'" + *varId + "\' nao declarada.";
			 throw ISourceErrorException(errorMsg, myLine);
		 }

		 fileStream << *varId << ";" << endl;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %r14
leaq 0x79b6(%rip), %rsi      # 0x2f75c
movl $0x7, %edx
movq %r14, %rdi
callq 0x7460
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xf994
testq %rax, %rax
je 0x27e24
movq 0x18(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x7460
movq %rax, %rbx
leaq 0x79a6(%rip), %rsi      # 0x2f788
movl $0x1, %edx
movq %rax, %rdi
callq 0x7460
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7030
movq %rax, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x72b0
movq 0x18(%rbx), %rdx
leaq 0x7935(%rip), %rsi      # 0x2f764
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0xca4b
leaq 0x792a(%rip), %rsi      # 0x2f76f
movq %r14, %rdi
callq 0x7850
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x27e6d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x27e78
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27ea1
callq 0x7350
movl $0x28, %edi
callq 0x71f0
movq %rax, %r14
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xfbae
movl 0x8(%rbx), %edx
movb $0x1, %r13b
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq 0xcad6
xorl %r13d, %r13d
leaq 0x131c9(%rip), %rsi     # 0x3b0b0
leaq -0x1b3c8(%rip), %rdx    # 0xcb26
movq %r14, %rdi
callq 0x7770
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x27f07
callq 0x7350
testb %r13b, %r13b
jne 0x27f11
jmp 0x27f19
movq %rax, %rbx
movq %r14, %rdi
callq 0x72e0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
jne 0x27f34
jmp 0x27f39
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27f39
callq 0x7350
movq %rbx, %rdi
callq 0x77b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::play(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int GameData::play(std::string root_word, std::string str) {
    int len = str.size();

    // std::cout<<"playing "<<str<<"on "<<root_word<<std::endl;
    // The word is being guessed
    if(len != 1) {
        return str == root_word;
    }

    // A letter is being guessed
    char letter = str[0];
    bool game_finished = true;

    for(int i = 0; i < word_length; ++i) {
        if(root_word[i] == letter) {
            current_string[i] = letter;
        }
        if(current_string[i] == '_') {
            game_finished = false;
        }
    }
    return game_finished;
}

// Assembly:
pushq %rax
movq 0x8(%rdx), %rcx
cmpl $0x1, %ecx
jne 0x3862
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3888
movq (%rdx), %rcx
movb (%rcx), %dl
movb $0x1, %cl
xorl %r8d, %r8d
xorl %r9d, %r9d
movq (%rsi), %r10
cmpb %dl, (%r10,%r9)
jne 0x3842
movb %dl, 0x4(%rdi,%r9)
movl %edx, %r10d
jmp 0x3847
movb 0x4(%rdi,%r9), %r10b
cmpb $0x5f, %r10b
movzbl %cl, %ecx
cmovel %r8d, %ecx
incq %r9
cmpq %r9, %rax
jne 0x382f
andb $0x1, %cl
movzbl %cl, %eax
jmp 0x388d
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
jne 0x388d
testq %rcx, %rcx
je 0x3888
movq (%rsi), %rsi
movq (%rdx), %rdi
movq %rcx, %rdx
callq 0x2250
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x388d
movl $0x1, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::serialize[abi:cxx11]()
std::string GameData::serialize() {
  //TODO send currently guessed characters too
  
  char data[1024];
  sprintf(data, "%d %s %d %d|", word_length, current_string, n_players, current_turn);
  std::string str(data);
  // std::cout<<"Serialized\t"<<str<<std::endl;
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x4(%rsi), %rcx
movl (%rsi), %edx
movl 0x18(%rsi), %r8d
movl 0x1c(%rsi), %r9d
leaq 0x178f(%rip), %rsi      # 0x50f3
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2070
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c42
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::getRandomWord[abi:cxx11]()
std::string GameData::getRandomWord() {
    std::ifstream file("words.txt");
    std::string word;

    std::random_device rd;
    unsigned long rand_no = std::uniform_int_distribution<unsigned long>()(rd) % 367516;

    while(--rand_no) getline(file, word);
    getline(file, word);

    // Remove trailing newline char
    word.erase(word.length() - 1);
    std::cout<<"Root Word: "<<word<<std::endl;
    return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x15a8, %rsp           # imm = 0x15A8
movq %rdi, %rbx
leaq 0x16e8(%rip), %rsi      # 0x5100
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2350
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x220(%rsp), %rdi
callq 0x3bc8
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq $-0x1, 0x8(%rdi)
leaq 0x220(%rsp), %rsi
movq %rdi, %rdx
callq 0x3cd8
movq %rax, %r15
movabsq $-0x49661782b4f511c7, %rcx # imm = 0xB699E87D4B0AEE39
mulq %rcx
shrq $0x12, %rdx
imulq $0x59b9c, %rdx, %rax    # imm = 0x59B9C
subq %rax, %r15
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
decq %r15
je 0x3ab7
movl $0xa, %esi
callq 0x2200
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2360
jmp 0x3a8c
movl $0xa, %esi
callq 0x2200
movsbl %al, %edx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2360
movq 0x8(%rbx), %rdx
subq $0x1, %rdx
jb 0x3b68
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
movq 0x34e7(%rip), %rdi      # 0x6fd8
leaq 0x1612(%rip), %rsi      # 0x510a
movl $0xb, %edx
callq 0x2270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x34c8(%rip), %rdi      # 0x6fd8
callq 0x2270
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
leaq 0x220(%rsp), %rdi
callq 0x21e0
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x15a8, %rsp           # imm = 0x15A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x15c3(%rip), %rdi      # 0x5132
leaq 0x15a8(%rip), %rsi      # 0x511e
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x22b0
jmp 0x3bc0
jmp 0x3b8a
movq %rax, %r14
jmp 0x3b9a
jmp 0x3b8a
movq %rax, %r14
leaq 0x220(%rsp), %rdi
callq 0x21e0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3bae
movq (%r12), %rsi
incq %rsi
callq 0x2240
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x3405
// File: /workspace/github_cpp_makefile_star2_O3/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: updateMaxFD(std::vector<Player, std::allocator<Player>>, int)
int updateMaxFD(std::vector<Player> clients, int maxfd){
    int x =maxfd;
    for(size_t i=0;i<clients.size();i++)
      x =std::max(x,clients[i].socket_id);
    return x;

}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
je 0x429f
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x20, %rcx
movl (%rcx), %eax
cmpl %eax, %esi
cmovgl %esi, %eax
addq $0x28, %rcx
movl %eax, %esi
decq %rdx
jne 0x428c
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: initFdset(std::vector<Player, std::allocator<Player>>, int)
fd_set initFdset(std::vector<Player> clients, int master){
    fd_set temp;
    FD_ZERO(&temp);
    FD_SET(master,&temp);
    for(size_t i=0;i<clients.size();i++){
        if(clients[i].socket_id)
            FD_SET(clients[i].socket_id,&temp);
    }
    return temp;
}

// Assembly:
movl %edx, %ecx
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movl %edx, %eax
andl $-0x40, %eax
subl %eax, %ecx
movl $0x1, %r8d
shlq %cl, %r8
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
sarl $0x6, %edx
movslq %edx, %rcx
orq %r8, (%rdi,%rcx,8)
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
je 0x4349
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rsi
cmpq $0x1, %rsi
adcq $0x0, %rsi
addq $0x20, %rdx
movl (%rdx), %ecx
testl %ecx, %ecx
je 0x4340
leal 0x3f(%rcx), %edi
testl %ecx, %ecx
cmovnsl %ecx, %edi
movl %edi, %r8d
andl $-0x40, %r8d
subl %r8d, %ecx
movl $0x1, %r8d
shlq %cl, %r8
sarl $0x6, %edi
movslq %edi, %rcx
orq %r8, (%rax,%rcx,8)
addq $0x28, %rdx
decq %rsi
jne 0x4315
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/examples/objects_as_params/main.cpp
// Function: MyNs::Impl::SimpleObject::CreateNewObject(MyNs::IFaces::IOutputObject**)
virtual Boss::RetCode BOSS_CALL CreateNewObject(IFaces::IOutputObject **obj)
      {
        try
        {
          auto NewInst = Boss::Base<OutputObject>::Create();
          return NewInst.QueryInterface(obj);
        }
        catch (...)
        {
        }
        return Boss::Status::Fail;
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17856
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1765d
movq (%rdi), %rax
movl $0xc3c67a7b, %esi       # imm = 0xC3C67A7B
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17662
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x17662
movq %rax, %rdi
callq 0x17483
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17650
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x17650
jmp 0x1762e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x180b0
callq 0x18120
movl $0x2, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRow(int)
int findRow(int id)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (id == table[i].identifier)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
movq 0x7ca4(%rip), %rcx      # 0xb230
movq 0x7c95(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x35bb
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
cmpl %edi, (%rdx)
je 0x35bc
incq %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0x35ab
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByID_MinHopCount(int)
int findRowByID_MinHopCount(int id)
{
	int min_hop_count = 10000;
	int index = -1;
	for (int i = 0; i < table.size(); i++)
	{
		if (id == table[i].identifier)
		{
			if (table[i].hop_count < min_hop_count)
			{
				index = i;
				min_hop_count = table[i].hop_count;
			}
		}
	}
	return index;
}

// Assembly:
movq 0x7c6a(%rip), %rcx      # 0xb230
movq 0x7c5b(%rip), %rdx      # 0xb228
subq %rdx, %rcx
je 0x360b
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0x2710, %esi           # imm = 0x2710
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
cmpl %edi, (%rdx)
jne 0x35fe
movl 0xc(%rdx), %r9d
cmpl %esi, %r9d
cmovll %r9d, %esi
cmovll %r8d, %eax
incq %r8
addq $0x40, %rdx
cmpq %r8, %rcx
jne 0x35eb
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByFD(int)
int findRowByFD(int fd)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
movq 0x7c18(%rip), %rcx      # 0xb230
movq 0x7c09(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x364b
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x4, %rdx
xorl %esi, %esi
cmpl %edi, (%rdx)
je 0x364c
incq %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0x363b
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByFDAndID(int, int)
int findRowByFDAndID(int fd, int id)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd and id == table[i].identifier)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
movq 0x7bda(%rip), %rcx      # 0xb230
movq 0x7bcb(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x368f
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x4, %rdx
xorl %r8d, %r8d
cmpl %edi, (%rdx)
jne 0x3683
cmpl %esi, -0x4(%rdx)
je 0x3690
incq %r8
addq $0x40, %rdx
cmpq %r8, %rcx
jne 0x367a
retq
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> findAllRowsByType(string type)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (table[i].type == type)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x4(%rsp)
movq 0x7b71(%rip), %r12      # 0xb230
movq 0x7b62(%rip), %r13      # 0xb228
cmpq %r13, %r12
je 0x3751
movq %rsi, %r14
xorl %eax, %eax
leaq 0x4(%rsp), %r15
xorl %ebp, %ebp
shlq $0x6, %rax
movq 0x18(%r13,%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3734
testq %rdx, %rdx
je 0x3705
addq %r13, %rax
addq $0x10, %rax
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x2280
testl %eax, %eax
jne 0x3734
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x371b
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3734
movq %rbx, %rdi
movq %r15, %rdx
callq 0x77aa
movq 0x7b03(%rip), %r12      # 0xb230
movq 0x7af4(%rip), %r13      # 0xb228
movslq 0x4(%rsp), %rax
incq %rax
movl %eax, 0x4(%rsp)
movq %r12, %rcx
subq %r13, %rcx
sarq $0x6, %rcx
movl %eax, %ebp
cmpq %rax, %rcx
ja 0x36db
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
testq %rdi, %rdi
je 0x377a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByFD(int)
vector<int> findAllRowsByFD(int fd)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0xc(%rsp)
movq 0x7a86(%rip), %rax      # 0xb230
movq 0x7a77(%rip), %rcx      # 0xb228
cmpq %rcx, %rax
je 0x3817
movl %esi, %ebp
xorl %edx, %edx
leaq 0xc(%rsp), %r14
xorl %edi, %edi
shlq $0x6, %rdx
cmpl %ebp, 0x4(%rcx,%rdx)
jne 0x37fa
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x37e1
movl %edi, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x37fa
movq %rbx, %rdi
movq %r14, %rdx
callq 0x77aa
movq 0x7a3d(%rip), %rax      # 0xb230
movq 0x7a2e(%rip), %rcx      # 0xb228
movslq 0xc(%rsp), %rdx
incq %rdx
movl %edx, 0xc(%rsp)
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x6, %rsi
movl %edx, %edi
cmpq %rdx, %rsi
ja 0x37c1
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x383a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CreateBrink(double*, double*)
bbrink_t *CreateBrink (vec3_t start, vec3_t stop)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);

	VectorCopy (start, b->start);
	VectorCopy (stop, b->stop);
	VectorSubtract (stop, start, b->direction);

	b->numnodes = 1;
	b->nodes = new std::vector< bbrinknode_t >;
	bbrinknode_t newnode;
	newnode.isleaf = true;
	newnode.clipnode = NULL;
	b->nodes->push_back (newnode);
	
	// CreateBrink must be followed by BrinkSplitClipnode
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x60, %edi
callq 0x4400
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl $0x1, %esi
callq 0xa655
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x10(%r14), %xmm1
movsd %xmm1, 0x28(%rbx)
movupd (%r15), %xmm2
movupd %xmm2, (%rbx)
movupd (%r14), %xmm3
movupd %xmm3, 0x18(%rbx)
subpd %xmm2, %xmm3
movupd %xmm3, 0x30(%rbx)
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rbx)
movl $0x1, 0x48(%rbx)
movl $0x18, %edi
callq 0x42f0
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rax, 0x50(%rbx)
leaq 0x8(%rsp), %rdx
movb $0x1, (%rdx)
movq %rcx, 0x20(%rdx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x11a88
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: PrintBrink(bbrink_t const*)
void PrintBrink (const bbrink_t *b)
{
	Log ("direction %f %f %f start %f %f %f stop %f %f %f\n", b->direction[0], b->direction[1], b->direction[2], b->start[0], b->start[1], b->start[2], b->stop[0], b->stop[1], b->stop[2]);
	Log ("numnodes %d\n", b->numnodes);
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *n = &(*b->nodes)[i];
		if (n->isleaf)
		{
			Log ("leaf[%d] content %d\n", i, n->content);
		}
		else
		{
			Log ("node[%d]-[%d:%d] plane %f %f %f %f\n", i, n->children[0], n->children[1], n->plane->normal[0], n->plane->normal[1], n->plane->normal[2], n->plane->dist);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm0
movsd 0x38(%rdi), %xmm1
movsd 0x40(%rdi), %xmm2
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm4
movsd 0x10(%rdi), %xmm5
movsd 0x18(%rdi), %xmm6
movsd 0x20(%rdi), %xmm7
movsd 0x28(%rdi), %xmm8
movsd %xmm8, (%rsp)
leaq 0x128fc(%rip), %rdi     # 0x204d4
movb $0x8, %al
callq 0x9bae
movl 0x48(%rbx), %esi
leaq 0x1291c(%rip), %rdi     # 0x20505
xorl %eax, %eax
callq 0x9bae
cmpl $0x0, 0x48(%rbx)
jle 0xdc6e
movl $0x18, %r13d
leaq 0x1290f(%rip), %r14     # 0x20512
leaq 0x1291d(%rip), %r15     # 0x20527
xorl %r12d, %r12d
movq 0x50(%rbx), %rax
movq (%rax), %rax
cmpb $0x1, -0x18(%rax,%r13)
jne 0xdc2f
movl (%rax,%r13), %edx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x9bae
jmp 0xdc5e
movl -0x8(%rax,%r13), %edx
movl -0x4(%rax,%r13), %ecx
movq -0x10(%rax,%r13), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x30(%rax), %xmm3
movq %r15, %rdi
movl %r12d, %esi
movb $0x4, %al
callq 0x9bae
incq %r12
movslq 0x48(%rbx), %rax
addq $0x28, %r13
cmpq %rax, %r12
jl 0xdc0d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BrinkSplitClipnode(bbrink_t*, plane_t const*, int, bclipnode_s*, bclipnode_s*, bclipnode_s*)
void BrinkSplitClipnode (bbrink_t *b, const dplane_t *plane, int planenum, bclipnode_t *prev, bclipnode_t *n0, bclipnode_t *n1)
{
	int found;
	int numfound = 0;
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *node = &(*b->nodes)[i];
		if (node->isleaf && node->clipnode == prev)
		{
			found = i;
			numfound++;
		}
	}
	if (numfound == 0)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: couldn't find clipnode");
		hlassume (false, assume_first);
	}
	if (numfound > 1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: found more than one clipnode");
		hlassume (false, assume_first);
	}
	if (n0 == n1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: n0 == n1");
		hlassume (false, assume_first);
	}
	b->nodes->resize (b->numnodes + 2);
	bbrinknode_t *node = &(*b->nodes)[found];
	bbrinknode_t *front = &(*b->nodes)[b->numnodes];
	bbrinknode_t *back = &(*b->nodes)[b->numnodes + 1];
	
	node->clipnode = NULL;
	node->isleaf = false;
	node->plane = plane;
	node->planenum = planenum;
	node->children[0] = b->numnodes;
	node->children[1] = b->numnodes + 1;
	
	front->isleaf = true;
	front->content = n0->content;
	front->clipnode = n0;

	back->isleaf = true;
	back->content = n1->content;
	back->clipnode = n1;

	b->numnodes += 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movslq 0x48(%rdi), %rdx
xorl %eax, %eax
leaq 0x128a9(%rip), %rdi     # 0x2054b
testq %rdx, %rdx
jle 0xdcef
movq 0x50(%r14), %rsi
movq (%rsi), %rsi
addq $0x20, %rsi
xorl %r9d, %r9d
cmpq %rcx, (%rsi)
sete %r10b
andb -0x20(%rsi), %r10b
movzbl %r10b, %r10d
addl %r10d, %eax
testb %r10b, %r10b
cmovnel %r9d, %r8d
incq %r9
addq $0x28, %rsi
cmpq %r9, %rdx
jne 0xdcb5
movslq %r8d, %r13
testl %eax, %eax
je 0xdcf2
cmpl $0x1, %eax
je 0xdd02
leaq 0x12899(%rip), %rdi     # 0x20586
jmp 0xdcf2
xorl %r13d, %r13d
xorl %eax, %eax
callq 0xa10c
xorl %edi, %edi
xorl %esi, %esi
callq 0xa655
cmpq %rbx, %r15
jne 0xdd1e
leaq 0x128b9(%rip), %rdi     # 0x205c7
xorl %eax, %eax
callq 0xa10c
xorl %edi, %edi
xorl %esi, %esi
callq 0xa655
movq 0x50(%r14), %rdi
movslq 0x48(%r14), %rsi
addq $0x2, %rsi
callq 0x117e0
movq 0x50(%r14), %rax
movq (%rax), %rax
leaq (,%r13,4), %rcx
addq %r13, %rcx
movslq 0x48(%r14), %rdx
leaq (%rdx,%rdx,4), %rdx
movq $0x0, 0x20(%rax,%rcx,8)
movb $0x0, (%rax,%rcx,8)
movq %r12, 0x8(%rax,%rcx,8)
movl %ebp, 0x4(%rax,%rcx,8)
movl 0x48(%r14), %esi
movl %esi, 0x10(%rax,%rcx,8)
incl %esi
movl %esi, 0x14(%rax,%rcx,8)
movb $0x1, %cl
movb %cl, (%rax,%rdx,8)
movl 0x20(%r15), %esi
movl %esi, 0x18(%rax,%rdx,8)
movq %r15, 0x20(%rax,%rdx,8)
movb %cl, 0x28(%rax,%rdx,8)
movl 0x20(%rbx), %ecx
movl %ecx, 0x40(%rax,%rdx,8)
movq %rbx, 0x48(%rax,%rdx,8)
addl $0x2, 0x48(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BrinkReplaceClipnode(bbrink_t*, bclipnode_s*, bclipnode_s*)
void BrinkReplaceClipnode (bbrink_t *b, bclipnode_t *prev, bclipnode_t *n)
{
	int found;
	int numfound = 0;
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *node = &(*b->nodes)[i];
		if (node->isleaf && node->clipnode == prev)
		{
			found = i;
			numfound++;
		}
	}
	if (numfound == 0)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: couldn't find clipnode");
		hlassume (false, assume_first);
	}
	if (numfound > 1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: found more than one clipnode");
		hlassume (false, assume_first);
	}
	bbrinknode_t *node = &(*b->nodes)[found];
	node->clipnode = n;
	node->content = n->content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movslq 0x48(%rdi), %rcx
xorl %eax, %eax
leaq 0x12790(%rip), %rdi     # 0x2054b
testq %rcx, %rcx
jle 0xde08
movq 0x50(%r14), %rdx
movq (%rdx), %rdx
addq $0x20, %rdx
xorl %r9d, %r9d
cmpq %rsi, (%rdx)
sete %r10b
andb -0x20(%rdx), %r10b
movzbl %r10b, %r10d
addl %r10d, %eax
testb %r10b, %r10b
cmovnel %r9d, %r8d
incq %r9
addq $0x28, %rdx
cmpq %r9, %rcx
jne 0xddce
movslq %r8d, %r15
testl %eax, %eax
je 0xde0b
cmpl $0x1, %eax
je 0xde1b
leaq 0x12780(%rip), %rdi     # 0x20586
jmp 0xde0b
xorl %r15d, %r15d
xorl %eax, %eax
callq 0xa10c
xorl %edi, %edi
xorl %esi, %esi
callq 0xa655
movq 0x50(%r14), %rax
movq (%rax), %rax
leaq (%r15,%r15,4), %rcx
movq %rbx, 0x20(%rax,%rcx,8)
movl 0x20(%rbx), %edx
movl %edx, 0x18(%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreepoint(int&, bool)
btreepoint_t *AllocTreepoint (int &numobjects, bool infinite)
{
	numobjects++;
	btreepoint_t *tp = (btreepoint_t *)malloc (sizeof (btreepoint_t));
	hlassume (tp != NULL, assume_NoMemory);
	tp->edges = new btreeedge_l ();
	tp->infinite = infinite;
	return tp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
incl (%rdi)
movl $0x40, %edi
callq 0x4400
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl $0x1, %esi
callq 0xa655
movl $0x18, %edi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%r14)
movb %bl, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeedge(int&, bool)
btreeedge_t *AllocTreeedge (int &numobjects, bool infinite)
{
	numobjects++;
	btreeedge_t *te = (btreeedge_t *)malloc (sizeof (btreeedge_t));
	hlassume (te != NULL, assume_NoMemory);
	te->points[0].p = NULL;
	te->points[0].side = false;
	te->points[1].p = NULL;
	te->points[1].side = true;
	te->faces = new btreeface_l ();
	te->infinite = infinite;
	// should be followed by SetEdgePoints
	return te;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
incl (%rdi)
movl $0x48, %edi
callq 0x4400
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl $0x1, %esi
callq 0xa655
xorl %r15d, %r15d
movq %r15, (%r14)
movb $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
movb $0x1, 0x18(%r14)
movl $0x18, %edi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x28(%r14)
movb %bl, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachPointToEdge(btreeedge_s*, btreepoint_s*, bool)
void AttachPointToEdge (btreeedge_t *te, btreepoint_t *tp, bool side)
{
	if (te->points[side].p)
	{
		PrintOnce ("AttachPointToEdge: internal error: point occupied.");
		hlassume (false, assume_first);
	}
	if (te->infinite && !tp->infinite)
	{
		PrintOnce ("AttachPointToEdge: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	te->points[side].p = tp;

	btreeedge_r er;
	er.e = te;
	er.side = side;
	tp->edges->push_back (er);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %r12d
shll $0x4, %r12d
cmpq $0x0, (%rdi,%r12)
je 0xdf24
leaq 0x126e0(%rip), %rdi     # 0x205f4
xorl %eax, %eax
callq 0xa10c
xorl %edi, %edi
xorl %esi, %esi
callq 0xa655
addq %r14, %r12
cmpb $0x1, 0x20(%r14)
jne 0xdf4c
cmpb $0x0, 0x18(%r15)
jne 0xdf4c
leaq 0x126eb(%rip), %rdi     # 0x20627
xorl %eax, %eax
callq 0xa10c
xorl %edi, %edi
xorl %esi, %esi
callq 0xa655
movq %r15, (%r12)
movq 0x20(%r15), %r15
movl $0x20, %edi
callq 0x42f0
movq %r14, 0x10(%rax)
movb %bl, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4070
incq 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeface(int&, bool)
btreeface_t *AllocTreeface (int &numobjects, bool infinite)
{
	numobjects++;
	btreeface_t *tf = (btreeface_t *)malloc (sizeof (btreeface_t));
	hlassume (tf != NULL, assume_NoMemory);
	tf->edges = new btreeedge_l ();
	tf->leafs[0].l = NULL;
	tf->leafs[0].side = false;
	tf->leafs[1].l = NULL;
	tf->leafs[1].side = true;
	tf->infinite = infinite;
	return tf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
incl (%rdi)
movl $0x48, %edi
callq 0x4400
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl $0x1, %esi
callq 0xa655
movl $0x18, %edi
callq 0x42f0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movb $0x0, 0x18(%r14)
movq %rcx, 0x20(%r14)
movb $0x1, 0x28(%r14)
movb %bl, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq