LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x306a1(%rip), %rax     # 0x3c080
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 0x8390
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x10d2a
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 0x8350
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbc12
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0xbc0e
movq %rsi, %r14
movl $0x40, %edi
callq 0x8390
leaq 0x303a0(%rip), %rcx     # 0x3bf70
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 0xb526
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_O1/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 0xbc80
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xbc7c
movq %rsi, %r14
movl $0x40, %edi
callq 0x8390
leaq 0x30332(%rip), %rcx     # 0x3bf70
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 0xb526
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_O1/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 0xbcee
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xbcea
movq %rsi, %r14
movl $0x40, %edi
callq 0x8390
leaq 0x302c4(%rip), %rcx     # 0x3bf70
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 0xb526
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_O1/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 0xbf22
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0xbf1e
movq %rsi, %r14
movl $0x40, %edi
callq 0x8390
leaq 0x30090(%rip), %rcx     # 0x3bf70
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 0xb526
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_O1/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 0x8740
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0xbfb8
movq 0x31062(%rip), %rdi     # 0x3cfc8
leaq 0x249ae(%rip), %rsi     # 0x3091b
movl $0x1b, %edx
callq 0x8460
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x31043(%rip), %rdi     # 0x3cfc8
callq 0x8460
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x82b0
xorl %ebx, %ebx
jmp 0xc02c
leaq -0x238(%rbp), %r14
leaq 0x24911(%rip), %rsi     # 0x308d7
movl $0x14, %edx
movq %r14, %rdi
callq 0x8460
leaq 0x24912(%rip), %rsi     # 0x308ec
movl $0x15, %edx
movq %r14, %rdi
callq 0x8460
leaq 0x24914(%rip), %rsi     # 0x30902
movl $0xc, %edx
movq %r14, %rdi
callq 0x8460
movq (%rbx), %rax
leaq -0x248(%rbp), %rsi
movq %rbx, %rdi
callq *(%rax)
leaq 0x248fe(%rip), %rsi     # 0x3090f
movl $0xb, %edx
movq %r14, %rdi
callq 0x8460
movb $0x1, %bl
leaq -0x248(%rbp), %rdi
callq 0x8070
leaq -0x248(%rbp), %rdi
callq 0x8890
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xc0ce
movq %rbx, %rdi
callq 0x8190
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x29390
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x30f55(%rip), %rdi     # 0x3cfc8
callq 0x8460
movq %rax, %rdi
callq 0x81e0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc092
callq 0x8350
leaq -0x248(%rbp), %rdi
callq 0x8070
callq 0x8700
jmp 0xbfb4
movq %rax, %rbx
jmp 0xc0ce
jmp 0xc0af
movq %rax, %rbx
jmp 0xc0c9
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0c9
callq 0x8350
callq 0x8700
leaq -0x248(%rbp), %rdi
callq 0x8890
movq %rbx, %rdi
callq 0x87b0
movq %rax, %rdi
callq 0xc37e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e349(%rip), %rsi     # 0x2bc5b
movq %r15, %rdi
callq 0x8100
testl %eax, %eax
je 0xd95b
leaq 0x1e331(%rip), %rsi     # 0x2bc56
movq %r15, %rdi
callq 0x8100
testl %eax, %eax
je 0xd972
leaq 0x1e9dc(%rip), %rsi     # 0x2c314
movq %r15, %rdi
callq 0x8100
testl %eax, %eax
jne 0xd9a1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e9bd(%rip), %rsi     # 0x2c30f
leaq 0x1e9c1(%rip), %rdx     # 0x2c31a
jmp 0xd987
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e99b(%rip), %rsi     # 0x2c304
leaq 0x1e997(%rip), %rdx     # 0x2c307
jmp 0xd987
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e988(%rip), %rsi     # 0x2c308
leaq 0x1e987(%rip), %rdx     # 0x2c30e
movq %rbx, %rdi
callq 0x1d592
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 0x1e96a(%rip), %rsi     # 0x2c31b
leaq 0x1e981(%rip), %rdx     # 0x2c339
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x1d592
movl $0x28, %edi
callq 0x81f0
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 0x10d2a
movl 0x8(%r14), %edx
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc12
xorl %r15d, %r15d
leaq 0x2e657(%rip), %rsi     # 0x3c060
leaq 0x252(%rip), %rdx       # 0xdc62
movq %rbx, %rdi
callq 0x8770
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xda31
callq 0x8350
jmp 0xda31
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xda3e
movq %rbx, %rdi
callq 0x82e0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xda4c
callq 0x8350
movq %r14, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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)
setne %r15b
je 0xdaff
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 0x10d2a
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xdac3
testq %rdx, %rdx
je 0xdac8
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x83e0
testl %eax, %eax
sete %r12b
jmp 0xdacb
xorl %r12d, %r12d
jmp 0xdacb
movb $0x1, %r12b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xdadd
callq 0x8350
testb %r12b, %r12b
jne 0xdb01
incq %r13
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
setb %r15b
jb 0xda80
jmp 0xdb09
jmp 0xdb09
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %r12
testb $0x1, %r15b
jne 0xdb5b
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xdb58
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 0x10d2a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda54
movq %rax, %r12
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xdb5b
callq 0x8350
jmp 0xdb5b
xorl %r12d, %r12d
movq %r12, %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 0xdb7e
callq 0x8350
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %r14
movq %rsi, -0x30(%rbp)
leaq -0x80(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x10d2a
movq %r14, %rdi
movq %r15, %rsi
callq 0xda54
movq %rax, %r15
movq -0x90(%rbp), %rdi
cmpq %r12, %rdi
je 0xeda7
callq 0x8350
testq %r15, %r15
jne 0xede3
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0xedc4
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0xedd4
addq $0x8, %r14
leaq -0x30(%rbp), %rdx
movq %r14, %rdi
callq 0xeea8
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 0x1d8d0(%rip), %rsi     # 0x2c6c2
leaq 0x1d8ec(%rip), %rdx     # 0x2c6e5
leaq -0x50(%rbp), %rdi
callq 0x1d592
movl $0x28, %edi
callq 0x81f0
movq %rax, %r14
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x10d2a
movb $0x1, %r12b
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0xdc12
xorl %r12d, %r12d
leaq 0x2d21a(%rip), %rsi     # 0x3c060
leaq -0x11eb(%rip), %rdx     # 0xdc62
movq %r14, %rdi
callq 0x8770
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xee6e
callq 0x8350
jmp 0xee6e
movq %rax, %rbx
movb $0x1, %r12b
testb %r12b, %r12b
je 0xee7b
movq %r14, %rdi
callq 0x82e0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0xee9a
jmp 0xee9f
movq %rax, %rbx
jmp 0xee9f
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r12, %rdi
je 0xee9f
callq 0x8350
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b647(%rip), %rax     # 0x3c080
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x10a4b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x10a5a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x10a7c
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x10a74
callq 0x8350
movq %r14, %rdi
callq 0x8350
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x10aa7
leaq 0x20(%r14), %rdi
callq 0xf39a
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x10a9f
callq 0x8350
movq %r14, %rdi
callq 0x8350
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x10ac9
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x10ac1
callq 0x8350
movq %r14, %rdi
callq 0x8350
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x10aef
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x10ae3
callq 0x8350
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8350
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8490
testq %r14, %r14
je 0x28a37
movq -0x30(%rbp), %rax
movq (%rax), %r15
xorl %r12d, %r12d
movabsq $-0x7bdef7bdef7bdef7, %r13 # imm = 0x8421084210842109
leaq 0x864d(%rip), %rbx      # 0x31050
callq 0x80e0
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 0x28a03
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_O1/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 0x7680(%rip), %rsi      # 0x307b8
movl $0x7, %edx
movq %r14, %rdi
callq 0x8460
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x10b10
testq %rax, %rax
je 0x291b6
movq 0x18(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x8460
movq %rax, %rbx
leaq 0x7670(%rip), %rsi      # 0x307e4
movl $0x1, %edx
movq %rax, %rdi
callq 0x8460
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x82b0
movq 0x18(%rbx), %rdx
leaq 0x75ff(%rip), %rsi      # 0x307c0
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0xdb86
leaq 0x75f4(%rip), %rsi      # 0x307cb
movq %r14, %rdi
callq 0x8850
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x291ff
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2920a
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 0x29233
callq 0x8350
movl $0x28, %edi
callq 0x81f0
movq %rax, %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x10d2a
movl 0x8(%rbx), %edx
movb $0x1, %r12b
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq 0xdc12
xorl %r12d, %r12d
leaq 0x12de8(%rip), %rsi     # 0x3c060
leaq -0x1b61d(%rip), %rdx    # 0xdc62
movq %r14, %rdi
callq 0x8770
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x292a0
callq 0x8350
jmp 0x292a0
movq %rax, %rbx
movb $0x1, %r12b
testb %r12b, %r12b
je 0x292ad
movq %r14, %rdi
callq 0x82e0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
jne 0x292c8
jmp 0x292cd
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x292cd
callq 0x8350
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::init(int)
void GameData::init(int root_word_len) {
    word_length = root_word_len;
    memset(current_string, '_', word_length);
    current_string[word_length] = '\0';

    n_players = 2;
    current_turn = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
addq $0x4, %rdi
movslq %esi, %r14
movl $0x5f, %esi
movq %r14, %rdx
callq 0x2140
movb $0x0, 0x4(%rbx,%r14)
movq $0x2, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x389e
movslq (%rdi), %rax
testq %rax, %rax
jle 0x38c4
movq (%rdx), %rcx
movb (%rcx), %dl
movb $0x1, %cl
xorl %r8d, %r8d
xorl %r9d, %r9d
movq (%rsi), %r10
cmpb %dl, (%r10,%r9)
jne 0x3881
movb %dl, 0x4(%rdi,%r9)
cmpb $0x5f, 0x4(%rdi,%r9)
movzbl %cl, %ecx
cmovel %r8d, %ecx
incq %r9
cmpq %r9, %rax
jne 0x3873
andb $0x1, %cl
movzbl %cl, %eax
jmp 0x38c9
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
jne 0x38c9
testq %rcx, %rcx
je 0x38c4
movq (%rsi), %rsi
movq (%rdx), %rdi
movq %rcx, %rdx
callq 0x2250
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x38c9
movl $0x1, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1753(%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 0x3c80
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void GameData::deserialize(std::string req){
    char data[1024]={0};
    req.copy(data, req.size());
    sscanf(data, "%d %s %d %d|", &word_length, current_string, &n_players, &current_turn);
    // std::cout<<"Deserializing\t"<<req<<std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x2140
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2050
leaq 0x4(%r14), %rcx
leaq 0x18(%r14), %r8
leaq 0x1c(%r14), %r9
leaq 0x16d1(%rip), %rsi      # 0x50f3
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16ac(%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 0x3c06
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq $-0x1, 0x8(%rdi)
leaq 0x220(%rsp), %rsi
movq %rdi, %rdx
callq 0x3d10
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 0x3af3
movl $0xa, %esi
callq 0x2200
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2360
jmp 0x3ac8
movl $0xa, %esi
callq 0x2200
movsbl %al, %edx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2360
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x3ba7
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
movq 0x34a8(%rip), %rdi      # 0x6fd8
leaq 0x15d3(%rip), %rsi      # 0x510a
movl $0xb, %edx
callq 0x2270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3489(%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 0x1584(%rip), %rdi      # 0x5132
leaq 0x1569(%rip), %rsi      # 0x511e
xorl %eax, %eax
callq 0x22b0
jmp 0x3bfd
jmp 0x3bc7
movq %rax, %r14
jmp 0x3bd7
jmp 0x3bc7
movq %rax, %r14
leaq 0x220(%rsp), %rdi
callq 0x21e0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3beb
movq (%r12), %rsi
incq %rsi
callq 0x2240
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x341f
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::init(char const*, int)
void  Client::init(const char* serverIp , int port ){
      int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_port = htons(port);
      socket_address.sin_addr.s_addr = inet_addr(serverIp);

      connect(socket_fd, (struct sockaddr *)&socket_address, sizeof(socket_address) );
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %ebp
movq %rsp, %r12
movw $0x2, (%r12)
rolw $0x8, %bx
movw %bx, 0x2(%r12)
movq %r14, %rdi
callq 0x2230
movl %eax, 0x4(%r12)
movl %ebp, %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x21b0
movl %ebp, (%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Client::init(std::string serverIp , int port ){
      char *IP;
      IP = (char*) malloc(serverIp.size());
      serverIp.copy(IP,serverIp.size());

      int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_port = htons(port);
      socket_address.sin_addr.s_addr = inet_addr(IP);

      connect(socket_fd, (struct sockaddr *)&socket_address, sizeof(socket_address) );
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq %r15, %rdi
callq 0x2280
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2050
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %r14d
movq %rsp, %r15
movw $0x2, (%r15)
rolw $0x8, %bp
movw %bp, 0x2(%r15)
movq %r12, %rdi
callq 0x2230
movl %eax, 0x4(%r15)
movl %r14d, %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x21b0
movl %r14d, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::forward(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Client::forward(std::string str){
    char data[1024]={0};
    str.copy(data, str.size());
    send(mastersocket, data,strlen(data),0);
    return str.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x2140
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2050
movl (%r14), %ebp
movq %r15, %rdi
callq 0x2100
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movl 0x8(%rbx), %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::forward(char const*)
int Client::forward(const char *str){
  char data[1024]={0};
  strcpy(data,str);
  send(mastersocket, data,strlen(data),0);
  return strlen(str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x2140
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21d0
movl (%r14), %ebp
movq %r15, %rdi
callq 0x2100
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movq %rbx, %rdi
callq 0x2100
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::init(int, int)
void Server::init(int port, int maxClients = 20){
      //CREATE SOCKET
      //So it is just an integer number that uniquely represents an opened file/socket in operating system
      int socket_fd = socket(AF_INET, SOCK_STREAM, 0); // creating socket
      //AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
      //SOCK_STREAM: TCP(reliable, connection oriented)
      //SOCK_DGRAM: UDP(unreliable, connectionless)

      //Bind ip and port to socket
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
      socket_address.sin_port = htons(port);         // this is the port number of running server
      bind(socket_fd, (sockaddr*)&socket_address , sizeof(socket_address));

      //LISTEN Socket
      listen(socket_fd , maxClients);
      //20 - max no of connections
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %r15d
leaq 0x8(%rsp), %rsi
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
rolw $0x8, %bp
movw %bp, 0x2(%rsi)
movl %eax, %edi
movl $0x10, %edx
callq 0x2060
movl %r15d, %edi
movl %ebx, %esi
callq 0x2260
movl %r15d, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::forward(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Server::forward(int client, std::string str){
      char data[1024]={0};
      str.copy(data, str.size());
      send(client, data,strlen(data),0);
      return str.size();
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %rbx
movl %esi, %ebp
movq %rsp, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2140
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2050
movq %r14, %rdi
callq 0x2100
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movl 0x8(%rbx), %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::forward(int, char const*)
int Server::forward(int client, const char *str){
    char data[1024]={0};
    strcpy(data,str);
    send(client, data,strlen(data),0);
    return strlen(str);
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %rbx
movl %esi, %ebp
movq %rsp, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2100
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movq %rbx, %rdi
callq 0x2100
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42d7
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 0x42c4
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4381
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 0x4378
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 0x434d
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1789c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1763c
movq (%rdi), %rax
movl $0xc3c67a7b, %esi       # imm = 0xC3C67A7B
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebx
jmp 0x17641
movl $0x2, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17651
movq (%rdi), %rax
callq *0x20(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x17497
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17674
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x17684
jmp 0x17659
movq %rax, %rbx
movq %rbx, %rdi
callq 0x18140
callq 0x181b0
movl $0x2, %ebx
jmp 0x17651
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7cab(%rip), %rcx      # 0xb230
movq 0x7c9c(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x35b4
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
cmpl %edi, (%rdx)
je 0x35b5
incq %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0x35a4
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c71(%rip), %rcx      # 0xb230
movq 0x7c62(%rip), %rdx      # 0xb228
subq %rdx, %rcx
je 0x3604
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 0x35f7
movl 0xc(%rdx), %r9d
cmpl %esi, %r9d
cmovll %r9d, %esi
cmovll %r8d, %eax
incq %r8
addq $0x40, %rdx
cmpq %r8, %rcx
jne 0x35e4
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c1f(%rip), %rcx      # 0xb230
movq 0x7c10(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x3644
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x4, %rdx
xorl %esi, %esi
cmpl %edi, (%rdx)
je 0x3645
incq %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0x3634
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7be1(%rip), %rcx      # 0xb230
movq 0x7bd2(%rip), %rdx      # 0xb228
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rdx, %rcx
je 0x3688
sarq $0x6, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x4, %rdx
xorl %r8d, %r8d
cmpl %edi, (%rdx)
jne 0x367c
cmpl %esi, -0x4(%rdx)
je 0x3689
incq %r8
addq $0x40, %rdx
cmpq %r8, %rcx
jne 0x3673
retq
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x4(%rsp)
movq 0x7b74(%rip), %rcx      # 0xb228
cmpq %rcx, 0x7b75(%rip)      # 0xb230
je 0x373c
movq %rsi, %r14
xorl %eax, %eax
leaq 0x4(%rsp), %r15
xorl %ebp, %ebp
shlq $0x6, %rax
movq 0x18(%rcx,%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3714
testq %rdx, %rdx
je 0x36f3
addq %rcx, %rax
addq $0x10, %rax
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x2280
testl %eax, %eax
jne 0x3714
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3709
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3714
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7716
movslq 0x4(%rsp), %rax
incq %rax
movl %eax, 0x4(%rsp)
movq 0x7b09(%rip), %rdx      # 0xb230
movq 0x7afa(%rip), %rcx      # 0xb228
subq %rcx, %rdx
sarq $0x6, %rdx
movl %eax, %ebp
cmpq %rax, %rdx
ja 0x36c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3761
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a97(%rip), %rcx      # 0xb228
cmpq %rcx, 0x7a98(%rip)      # 0xb230
je 0x37f8
movl %esi, %ebp
xorl %eax, %eax
leaq 0xc(%rsp), %r14
xorl %edx, %edx
shlq $0x6, %rax
cmpl %ebp, 0x4(%rcx,%rax)
jne 0x37d0
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x37c5
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x37d0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7716
movslq 0xc(%rsp), %rax
incq %rax
movl %eax, 0xc(%rsp)
movq 0x7a4d(%rip), %rsi      # 0xb230
movq 0x7a3e(%rip), %rcx      # 0xb228
subq %rcx, %rsi
sarq $0x6, %rsi
movl %eax, %edx
cmpq %rax, %rsi
ja 0x37a5
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x381b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2270
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CopyBrink(bbrink_t*)
bbrink_t *CopyBrink (bbrink_t *other)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);
	VectorCopy (other->direction, b->direction);
	VectorCopy (other->start, b->start);
	VectorCopy (other->stop, b->stop);
	b->numnodes = other->numnodes;
	b->nodes = new std::vector< bbrinknode_t >(*other->nodes);
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x60, %edi
callq 0x4400
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
movl $0x1, %esi
callq 0xa731
movups 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
movl $0x18, %edi
callq 0x42f0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x1195a
movq %r15, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x4300
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa731
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)
movb $0x1, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0xdd67
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rsi)
movupd 0x8(%rsp), %xmm0
movupd 0x18(%rsp), %xmm1
movupd %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
addq $0x28, %rsi
movq %rsi, 0x8(%rax)
jmp 0xdd74
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x11c96
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13711(%rip), %rdi     # 0x214dc
movb $0x8, %al
callq 0x9c96
movl 0x48(%rbx), %esi
leaq 0x13731(%rip), %rdi     # 0x2150d
xorl %eax, %eax
callq 0x9c96
cmpl $0x0, 0x48(%rbx)
jle 0xde61
movl $0x18, %r13d
leaq 0x13724(%rip), %r14     # 0x2151a
leaq 0x13732(%rip), %r15     # 0x2152f
xorl %r12d, %r12d
movq 0x50(%rbx), %rax
movq (%rax), %rax
cmpb $0x1, -0x18(%rax,%r13)
jne 0xde22
movl (%rax,%r13), %edx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x9c96
jmp 0xde51
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 0x9c96
incq %r12
movslq 0x48(%rbx), %rax
addq $0x28, %r13
cmpq %rax, %r12
jl 0xde00
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq