LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::or_()
pair<Token*, function<Token*(Token*)>> Evaluator::or_() {
    Token* op = new BinaryOperator(BinaryOperatorType::OR);
    Token* var1 = new Variable("L");
    Token* var2 = new Variable("R");
    List* signature = new List();
    signature->list.push_back(op);
    signature->list.push_back(var1);
    signature->list.push_back(var2);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            List* list = static_cast<List*>(input);

            Token* a_token = this->eval(list->list[1]);
            Token* b_token = this->eval(list->list[2]);

            if (a_token->type != TokenType::BOOLEAN) {
                Token* t = new Error("expect a boolean, got: " + a_token->debug() , input);
                return t;
            }

            if (b_token->type != TokenType::BOOLEAN) {
                Token* t = new Error("expect a boolean, got: " + a_token->debug(), input);
                return t;
            }

            Boolean* a = static_cast<Boolean*>(a_token);
            Boolean* b = static_cast<Boolean*>(b_token);

            Token* res = new Boolean(a->value || b->value);
            return res;
    });

    return res;
}

// 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
pushq $0x8
popq %rdi
callq 0x3200
movabsq $0x600000005, %rcx      # imm = 0x600000005
movq %rcx, (%rax)
movq %rax, -0x48(%rbp)
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x76db(%rip), %rsi      # 0xc277
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3100
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0x749c
leaq -0x88(%rbp), %rdi
callq 0x3140
movq %r15, -0x40(%rbp)
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x790e(%rip), %rsi      # 0xc4eb
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x749c
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x38(%rbp), %r12
movq %r15, (%r12)
pushq $0x20
popq %rdi
callq 0x3200
movq %rax, %r15
movl $0x1, (%rax)
leaq 0x8(%rax), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
leaq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x74b0
leaq -0x40(%rbp), %rsi
movq %r13, %rdi
callq 0x74b0
movq %r13, %rdi
movq %r12, %rsi
callq 0x74b0
movq %r15, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, 0x8(%rbx)
leaq 0x1d92(%rip), %rax      # 0x69f0
movq %rax, 0x20(%rbx)
leaq 0x1ec5(%rip), %rax      # 0x6b2e
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x4c94
jmp 0x4c9b
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3140
jmp 0x4c9e
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::and_()
pair<Token*, function<Token*(Token*)>> Evaluator::and_() {
    Token* op = new BinaryOperator(BinaryOperatorType::AND);
    Token* var1 = new Variable("L");
    Token* var2 = new Variable("R");
    List* signature = new List();
    signature->list.push_back(op);
    signature->list.push_back(var1);
    signature->list.push_back(var2);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            List* list = static_cast<List*>(input);

            Token* a_token = this->eval(list->list[1]);
            Token* b_token = this->eval(list->list[2]);

            if (a_token->type != TokenType::BOOLEAN) {
                Token* t = new Error("expect a boolean, got: " + a_token->debug(), input);
                return t;
            }

            if (b_token->type != TokenType::BOOLEAN) {
                Token* t = new Error("expect a boolean, got: " + b_token->debug(), input);
                return t;
            }

            Boolean* a = static_cast<Boolean*>(a_token);
            Boolean* b = static_cast<Boolean*>(b_token);

            Token* res = new Boolean(a->value && b->value);
            return res;
    });

    return res;
}

// 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
pushq $0x8
popq %rdi
callq 0x3200
movabsq $0x500000005, %rcx      # imm = 0x500000005
movq %rcx, (%rax)
movq %rax, -0x48(%rbp)
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x7583(%rip), %rsi      # 0xc277
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3100
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0x749c
leaq -0x88(%rbp), %rdi
callq 0x3140
movq %r15, -0x40(%rbp)
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x77b6(%rip), %rsi      # 0xc4eb
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x749c
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x38(%rbp), %r12
movq %r15, (%r12)
pushq $0x20
popq %rdi
callq 0x3200
movq %rax, %r15
movl $0x1, (%rax)
leaq 0x8(%rax), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
leaq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x74b0
leaq -0x40(%rbp), %rsi
movq %r13, %rdi
callq 0x74b0
movq %r13, %rdi
movq %r12, %rsi
callq 0x74b0
movq %r15, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, 0x8(%rbx)
leaq 0x1da2(%rip), %rax      # 0x6b58
movq %rax, 0x20(%rbx)
leaq 0x1edb(%rip), %rax      # 0x6c9c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x4dec
jmp 0x4df3
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3140
jmp 0x4df6
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::definitions()
pair<Token*, function<Token*(Token*)>> Evaluator::definitions() {
    Token* op = new Atom("definitions");
    List* signature = new List();
    signature->list.push_back(op);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            for (size_t i = 0; i < this->state.size(); i++) {
                cout << this->state[i].first->debug() << '\n';
            }

            return nullptr;
    });

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x7467(%rip), %rsi      # 0xc298
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x3100
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x74d4
leaq -0x48(%rbp), %rdi
callq 0x3140
leaq -0x50(%rbp), %r12
movq %r15, (%r12)
pushq $0x20
popq %rdi
callq 0x3200
movq %rax, %r15
movl $0x1, (%rax)
leaq 0x8(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %r12, %rsi
callq 0x74b0
movq %r15, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, 0x8(%rbx)
leaq 0x1e2f(%rip), %rax      # 0x6cc6
movq %rax, 0x20(%rbx)
leaq 0x1ebc(%rip), %rax      # 0x6d5e
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3140
jmp 0x4ec7
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::print()
pair<Token*, function<Token*(Token*)>> Evaluator::print() {
    Token* op = new Atom("print");
    Token* input = new Variable("INPUT");
    List* signature = new List();
    signature->list.push_back(op);
    signature->list.push_back(input);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            List* input_list = static_cast<List*>(input);
            Token* res = this->eval(input_list->list[1]);
            cout << res->debug() << '\n';

            return res;
    });

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x73a1(%rip), %rsi      # 0xc2a4
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3100
leaq -0x80(%rbp), %rsi
movq %r15, %rdi
callq 0x74d4
leaq -0x80(%rbp), %rdi
callq 0x3140
movq %r15, -0x40(%rbp)
pushq $0x28
popq %rdi
callq 0x3200
movq %rax, %r15
leaq 0x7395(%rip), %rsi      # 0xc2d0
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x749c
leaq -0x60(%rbp), %rdi
callq 0x3140
leaq -0x38(%rbp), %r12
movq %r15, (%r12)
pushq $0x20
popq %rdi
callq 0x3200
movq %rax, %r15
movl $0x1, (%rax)
leaq 0x8(%rax), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
leaq -0x40(%rbp), %rsi
movq %r13, %rdi
callq 0x74b0
movq %r13, %rdi
movq %r12, %rsi
callq 0x74b0
movq %r15, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, 0x8(%rbx)
leaq 0x1dd8(%rip), %rax      # 0x6d88
movq %rax, 0x20(%rbx)
leaq 0x1e41(%rip), %rax      # 0x6dfc
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x4fe3
jmp 0x4fea
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3140
jmp 0x4fed
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::generateVariableArgument(Token*, Token*)
vector<pair<Variable*, Token*>> Evaluator::generateVariableArgument(Token* condition, Token* input) {
    vector<pair<Variable*, Token*>> arguments;
    if (condition->type == TokenType::VARIABLE) {
        Variable* var = static_cast<Variable*>(condition);
        arguments.push_back(make_pair(var, input));
    } else if (condition->type == TokenType::LIST) {
        List* params = static_cast<List*>(condition);
        List* args = static_cast<List*>(input);

        for (size_t i = 0; i < params->list.size(); i++) {
            if (params->list[i]->type == TokenType::VARIABLE) {
                Variable* var = static_cast<Variable*>(params->list[i]);
                arguments.push_back(make_pair(var, args->list[i]));
            }
        }
    }

    return arguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl (%rdx), %eax
cmpl $0x3, %eax
je 0x5075
cmpl $0x1, %eax
jne 0x5088
xorl %r13d, %r13d
leaq -0x38(%rbp), %r12
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x5088
movq (%rax,%r13,8), %rax
cmpl $0x3, (%rax)
jne 0x5070
movq 0x8(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7c5e
incq %r13
jmp 0x5038
leaq -0x38(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movq %rbx, %rdi
callq 0x7c5e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x509c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7bac
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: unaryOperatorToString[abi:cxx11](UnaryOperatorType)
string unaryOperatorToString(UnaryOperatorType type) {
	map<UnaryOperatorType, string> valid_operator;
	valid_operator[UnaryOperatorType::NOT] = "not";
	valid_operator[UnaryOperatorType::DEC] = "dec";

	return valid_operator[type];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x95a6
leaq 0x4270(%rip), %rsi      # 0xc498
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x95a6
leaq 0x4252(%rip), %rsi      # 0xc49c
movq %rax, %rdi
callq 0x3360
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x95f8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3290
leaq -0x40(%rbp), %rdi
callq 0x9b22
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x8281
jmp 0x8281
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x9b22
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: stringToUnaryOperator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
UnaryOperatorType stringToUnaryOperator(string s) {
	map<string, UnaryOperatorType> valid_operator;
	valid_operator["not"] = UnaryOperatorType::NOT;
	valid_operator["dec"] = UnaryOperatorType::DEC;

	return valid_operator[s];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x41d7(%rip), %rsi      # 0xc498
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x964a
andl $0x0, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x41ae(%rip), %rsi      # 0xc49c
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x964a
movl $0x1, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x96b4
movl (%rax), %ebx
leaq -0x60(%rbp), %rdi
callq 0x9b9e
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x834b
jmp 0x833d
jmp 0x834b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0x834e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9b9e
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: isUnaryOperator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isUnaryOperator(string s) {
	map<string, bool> valid_operator;
	valid_operator["not"] = true;
	valid_operator["dec"] = true;

	auto it = valid_operator.find(s);
	if (it == valid_operator.end()) {
		return false;
	}

	return valid_operator[s];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
andl $0x0, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
andq $0x0, 0x20(%r14)
leaq 0x410a(%rip), %rsi      # 0xc498
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x40e1(%rip), %rsi      # 0xc49c
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0xac78
cmpq %r14, %rax
je 0x8402
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x9788
movb (%rax), %bl
jmp 0x8404
xorl %ebx, %ebx
leaq -0x68(%rbp), %rdi
callq 0x9c1a
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x841c
jmp 0x842c
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3140
jmp 0x842f
jmp 0x842c
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x9c1a
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: binaryOperatorToString[abi:cxx11](BinaryOperatorType)
string binaryOperatorToString(BinaryOperatorType type) {
	map<BinaryOperatorType, string> valid_operator;
	valid_operator[BinaryOperatorType::PLUS] = "+";
	valid_operator[BinaryOperatorType::MINUS] = "-";
	valid_operator[BinaryOperatorType::DIV] = "/";
	valid_operator[BinaryOperatorType::TIMES] = "*";
	valid_operator[BinaryOperatorType::AND] = "and";
	valid_operator[BinaryOperatorType::OR] = "or";
	valid_operator[BinaryOperatorType::DEF] = "def";
	valid_operator[BinaryOperatorType::EQ] = "=";

	return valid_operator[type];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0xc(%rbp), %rsi
movl $0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x401e(%rip), %rsi      # 0xc4a0
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x4001(%rip), %rsi      # 0xc4a2
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x3, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3fe1(%rip), %rsi      # 0xc4a4
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3fc1(%rip), %rsi      # 0xc4a6
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x5, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3fa1(%rip), %rsi      # 0xc4a8
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x6, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3f83(%rip), %rsi      # 0xc4ac
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3f64(%rip), %rsi      # 0xc4af
movq %rax, %rdi
callq 0x3360
leaq -0xc(%rbp), %rsi
movl $0x7, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x97f2
leaq 0x3f46(%rip), %rsi      # 0xc4b3
movq %rax, %rdi
callq 0x3360
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9844
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3290
leaq -0x40(%rbp), %rdi
callq 0x9c96
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
jmp 0x85b0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x9c96
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: stringToBinaryOperator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BinaryOperatorType stringToBinaryOperator(string s) {
	map<string, BinaryOperatorType> valid_operator;
	valid_operator["+"] = BinaryOperatorType::PLUS;
	valid_operator["-"] = BinaryOperatorType::MINUS;
	valid_operator["/"] = BinaryOperatorType::DIV;
	valid_operator["*"] = BinaryOperatorType::TIMES;
	valid_operator["and"] = BinaryOperatorType::AND;
	valid_operator["or"] = BinaryOperatorType::OR;
	valid_operator["def"] = BinaryOperatorType::DEF;
	valid_operator["="] = BinaryOperatorType::EQ;

	return valid_operator[s];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x3eb0(%rip), %rsi      # 0xc4a0
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x1, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3e82(%rip), %rsi      # 0xc4a2
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
andl $0x0, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3e57(%rip), %rsi      # 0xc4a4
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x3, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3e29(%rip), %rsi      # 0xc4a6
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x2, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3dfb(%rip), %rsi      # 0xc4a8
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x5, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3dcf(%rip), %rsi      # 0xc4ac
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x6, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3da2(%rip), %rsi      # 0xc4af
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x4, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq 0x3d76(%rip), %rsi      # 0xc4b3
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9896
movl $0x7, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x9900
movl (%rax), %ebx
leaq -0x60(%rbp), %rdi
callq 0x9d12
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
jmp 0x87a4
jmp 0x87b2
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0x87b5
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9d12
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: isBinaryOperator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isBinaryOperator(string s) {
	map<string, bool> valid_operator;
	valid_operator["+"] = true;
	valid_operator["-"] = true;
	valid_operator["/"] = true;
	valid_operator["*"] = true;
	valid_operator["and"] = true;
	valid_operator["or"] = true;
	valid_operator["def"] = true;
	valid_operator["="] = true;

	auto it = valid_operator.find(s);

	if (it == valid_operator.end()) {
		return false;
	}

	return valid_operator[s];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
andl $0x0, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
andq $0x0, 0x20(%r14)
leaq 0x3cab(%rip), %rsi      # 0xc4a0
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3c80(%rip), %rsi      # 0xc4a2
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3c55(%rip), %rsi      # 0xc4a4
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3c2a(%rip), %rsi      # 0xc4a6
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3bff(%rip), %rsi      # 0xc4a8
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3bd6(%rip), %rsi      # 0xc4ac
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3bac(%rip), %rsi      # 0xc4af
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0x3b83(%rip), %rsi      # 0xc4b3
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3100
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x971e
movb $0x1, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0xac78
cmpq %r14, %rax
je 0x8977
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x9788
movb (%rax), %bl
jmp 0x8979
xorl %ebx, %ebx
leaq -0x68(%rbp), %rdi
callq 0x9c1a
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
jmp 0x89a9
jmp 0x89b9
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3140
jmp 0x89bc
jmp 0x89b9
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x9c1a
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: debugState(std::vector<State, std::allocator<State>>)
void debugState(vector<State> state) {
    for (size_t i = 0; i < state.size(); i++) {
        string res = "";
        switch (state[i]) {
            case State::LIST_START:
                res = "B";
                break;
            case State::CHAR:
                res = "C";
                break;
            case State::LIST_TOKEN:
                res = "L";
                break;
            case State::SPACE:
                res = "S";
                break;
            case State::COMMENT:
                res = "#";
                break;
        }

        std::cout << res;
    }

    std::cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x50(%rbp), %r15
leaq 0x36ff(%rip), %r12      # 0xc484
movq 0x923c(%rip), %r13      # 0x11fc8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rax, %r14
jae 0x8de3
movq %r15, %rdi
leaq 0x37dc(%rip), %rsi      # 0xc582
leaq -0x29(%rbp), %rdx
callq 0x3100
movq (%rbx), %rax
movl (%rax,%r14,4), %eax
cmpq $0x5, %rax
jae 0x8dcb
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x3360
movq %r13, %rdi
movq %r15, %rsi
callq 0x31e0
movq %r15, %rdi
callq 0x3140
incq %r14
jmp 0x8d8c
movq 0x91de(%rip), %rdi      # 0x11fc8
pushq $0xa
popq %rsi
callq 0x3240
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/BlinfoldKing[P]lisval/src/lib/parser.cpp
// Function: Token::debugToken[abi:cxx11]()
string Token::debugToken() {
	string res = "";
	switch (this->type) {
		case TokenType::ATOM:
			res += "ATOM";
			break;
		case TokenType::LIST:
			{
				res += "LIST{ ";
				List* l = static_cast<List*>(this);
				for (size_t i = 0; i < l->list.size(); i++) {
					res += l->list[i]->debugToken() + " ";
				}
				res += "}";
				break;
			}
		case TokenType::NUMBER:
			res += "NUMBER";
			break;
		case TokenType::VARIABLE:
			res += "VARIABLE";
			break;
		case TokenType::UNARY_OPERATOR:
			res += "UNARY_OPERATOR";
			break;
		case TokenType::BINARY_OPERATOR:
			res += "BINARY_OPERATOR";
			break;
		case TokenType::BOOLEAN:
			res += "BOOLEAN";
			break;
        case TokenType::ERROR:
            res += "ERROR";
            break;
		default:
			res += "UNKNOWN";
	}

	return res;
}

// 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 0x3344(%rip), %rsi      # 0xc582
leaq -0x48(%rbp), %rdx
callq 0x3100
movl (%r14), %eax
cmpq $0x8, %rax
ja 0x926c
leaq 0x31e1(%rip), %rcx      # 0xc438
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3271(%rip), %rsi      # 0xc4d8
jmp 0x931f
leaq 0x32b0(%rip), %rsi      # 0xc523
jmp 0x931f
leaq 0x3286(%rip), %rsi      # 0xc505
jmp 0x931f
leaq 0x3252(%rip), %rsi      # 0xc4dd
movq %rbx, %rdi
callq 0x3350
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r13
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x9339
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x9220
movq %r13, %rdi
movq %r15, %rsi
leaq 0x2d5a(%rip), %rdx      # 0xc029
callq 0x99bb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3370
movq %r13, %rdi
callq 0x3140
movq %r15, %rdi
callq 0x3140
incq %r12
jmp 0x929e
leaq 0x321a(%rip), %rsi      # 0xc515
jmp 0x931f
leaq 0x3219(%rip), %rsi      # 0xc51d
jmp 0x931f
leaq 0x31d9(%rip), %rsi      # 0xc4e6
jmp 0x931f
leaq 0x31d7(%rip), %rsi      # 0xc4ed
jmp 0x931f
leaq 0x31d7(%rip), %rsi      # 0xc4f6
movq %rbx, %rdi
callq 0x3350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31a4(%rip), %rsi      # 0xc4e4
movq %rbx, %rdi
callq 0x3350
jmp 0x9327
jmp 0x936a
jmp 0x936a
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3140
jmp 0x935f
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3140
jmp 0x936d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: ordenarObjetos()
void ordenarObjetos()
{
    int flag, aux;
    for(int j = 0; j < numObj; j++)
        vetIndObjOrd[j] = j;
    flag = 1;
    while(flag)
    {
        flag = 0;
        for(int j = 0; j < numObj - 1; j++)
        {
            if((double)vetValObj[vetIndObjOrd[j]]/vetPesObj[vetIndObjOrd[j]] <
               (double)vetValObj[vetIndObjOrd[j+1]]/vetPesObj[vetIndObjOrd[j+1]])
            {
                flag = 1;
                aux = vetIndObjOrd[j];
                vetIndObjOrd[j] = vetIndObjOrd[j+1];
                vetIndObjOrd[j+1] = aux;
            }
        }
    }
}

// Assembly:
movl 0x55e4(%rip), %ecx      # 0x8134
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
leaq 0x664d(%rip), %rsi      # 0x91b0
cmpq %rax, %rdx
je 0x2b73
movl %eax, (%rsi)
incq %rax
addq $0x4, %rsi
jmp 0x2b63
decl %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
pushq $0x1
popq %rcx
leaq 0x662a(%rip), %rdx      # 0x91b0
leaq 0x55b3(%rip), %rsi      # 0x8140
leaq 0x5d7c(%rip), %rdi      # 0x8910
movl %ecx, %r9d
testl %r9d, %r9d
je 0x2bf9
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %r8, %rax
je 0x2b97
movslq (%rdx,%r8,4), %r10
movslq 0x4(%rdx,%r8,4), %r11
incq %r8
movss (%rsi,%r11,4), %xmm0
movss (%rsi,%r10,4), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2pd %xmm1, %xmm0
movss (%rdi,%r11,4), %xmm1
movss (%rdi,%r10,4), %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd %xmm2, %xmm1
divpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
ucomisd %xmm0, %xmm1
jbe 0x2ba2
movl %r11d, -0x4(%rdx,%r8,4)
movl %r10d, (%rdx,%r8,4)
movl %ecx, %r9d
jmp 0x2ba2
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: grasp(int, double, tSolucao&, double&, double&)
void grasp(const int lrc, const double tempo_max, Solucao &s, double &tempo_melhor, double &tempo_total)
{
    clock_t hI, hF;
    Solucao s_vizinha;
    printf("\n\n>>> EXECUTANDO O GRASP...\n\n");
    tempo_total = tempo_melhor = 0;
    hI = clock();
    s.funObj = -INT_MAX;
    while(tempo_total < tempo_max)
    {
        heuConAleGul(s_vizinha, lrc);
        calcFO(s_vizinha);
        heuBLPM(s_vizinha);
        if(s_vizinha.funObj > s.funObj)
        {
            memcpy(&s, &s_vizinha, sizeof(s_vizinha));
            hF = clock();
            tempo_melhor = ((double)(hF - hI))/CLOCKS_PER_SEC;
            #ifdef DBG
                printf("FO: %d\tTempo: %.2f\n", s.funObj, tempo_melhor);
            #endif
        }
        hF = clock();
        tempo_total = ((double)(hF - hI))/CLOCKS_PER_SEC;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8a8, %rsp            # imm = 0x8A8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movsd %xmm0, (%rsp)
movl %edi, %ebp
leaq 0x2381(%rip), %rdi      # 0x5572
callq 0x21b0
andq $0x0, (%r14)
andq $0x0, (%rbx)
callq 0x20b0
movq %rax, %r12
movl $0x80000001, 0x898(%r15) # imm = 0x80000001
movsd (%rbx), %xmm0
leaq 0xc(%rsp), %r13
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x32b0
movq %r13, %rdi
movl %ebp, %esi
callq 0x3a8a
movq %r13, %rdi
callq 0x38ec
movq %r13, %rdi
callq 0x3bba
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x3292
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r13, %rsi
callq 0x20d0
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1dc0(%rip), %xmm0     # 0x5038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x1e48(%rip), %rdi      # 0x50d3
movb $0x1, %al
callq 0x2050
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1d91(%rip), %xmm0     # 0x5038
movsd %xmm0, (%rbx)
jmp 0x321a
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: vns(double, tSolucao&, double&, double&)
void vns(const double tempo_max, Solucao &s, double &tempo_melhor, double &tempo_total)
{
    int v;
    clock_t hI, hF;
    Solucao s_vizinha;
    printf("\n\n>>> EXECUTANDO O VNS...\n\n");
    hI = clock();
    heuConAle(s);
    calcFO(s);
    hF = clock();
    tempo_melhor = ((double)(hF - hI))/CLOCKS_PER_SEC;
    #ifdef DBG
        printf("FO: %d\tTempo: %.2f\n", s.funObj, tempo_melhor);
    #endif
    tempo_total = tempo_melhor;
    while(tempo_total < tempo_max)
    {
        v = 0;
        while(v < 2)
        {
            memcpy(&s_vizinha, &s, sizeof(s));
            if(v == 0)
                gerar_vizinha(s_vizinha);
            else
                gerar_vizinha2(s_vizinha);
            heuBLPM(s_vizinha);
            if(s_vizinha.funObj > s.funObj)
            {
                memcpy(&s, &s_vizinha, sizeof(s_vizinha));
                hF = clock();
                tempo_melhor = ((double)(hF - hI))/CLOCKS_PER_SEC;
                #ifdef DBG
                    printf("FO: %d\tTempo: %.2f\n", s.funObj, tempo_melhor);
                #endif
                v = 0;
            }
            else
                v++;
        }
        hF = clock();
        tempo_total = ((double)(hF - hI))/CLOCKS_PER_SEC;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8b8, %rsp            # imm = 0x8B8
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, 0x8(%rsp)
leaq 0x1f4f(%rip), %rdi      # 0x55a9
callq 0x21b0
callq 0x20b0
movq %rax, %r12
movq %r15, %rdi
callq 0x38af
movq %r15, %rdi
callq 0x38ec
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x19ac(%rip), %xmm0     # 0x5038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x1a34(%rip), %r13      # 0x50d3
movq %r13, %rdi
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
leaq 0x1c(%rsp), %rbp
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x376c
xorl %ebx, %ebx
cmpl $0x1, %ebx
jg 0x3752
movl $0x89c, %edx            # imm = 0x89C
movq %rbp, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rbp, %rdi
testl %ebx, %ebx
je 0x36f1
callq 0x3e4e
jmp 0x36f6
callq 0x39a2
movq %rbp, %rdi
callq 0x3bba
movl 0x8b4(%rsp), %eax
cmpl 0x898(%r15), %eax
jg 0x3712
incl %ebx
jmp 0x36ce
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %rbp, %rsi
callq 0x20d0
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1901(%rip), %xmm0     # 0x5038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
movq %r13, %rdi
movb $0x1, %al
callq 0x2050
jmp 0x36cc
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x18d1(%rip), %xmm0     # 0x5038
jmp 0x36b3
addq $0x8b8, %rsp            # imm = 0x8B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: ils(double, tSolucao&, double&, double&)
void ils(const double tempo_max, Solucao &s, double &tempo_melhor, double &tempo_total)
{
    clock_t hI, hF;
    Solucao s_vizinha;
    printf("\n\n>>> EXECUTANDO O ILS...\n\n");
    hI = clock();
    heuConAle(s);
    calcFO(s);
    heuBLPM(s);
    hF = clock();
    tempo_melhor = ((double)(hF - hI))/CLOCKS_PER_SEC;
    #ifdef DBG
        printf("FO: %d\tTempo: %.2f\n", s.funObj, tempo_melhor);
    #endif
    tempo_total = tempo_melhor;
    while(tempo_total < tempo_max)
    {
        memcpy(&s_vizinha, &s, sizeof(s));
        gerar_vizinha(s_vizinha);
        heuBLPM(s_vizinha);
        if(s_vizinha.funObj > s.funObj)
        {
            memcpy(&s, &s_vizinha, sizeof(s_vizinha));
            hF = clock();
            tempo_melhor = ((double)(hF - hI))/CLOCKS_PER_SEC;
            #ifdef DBG
                printf("FO: %d\tTempo: %.2f\n", s.funObj, tempo_melhor);
            #endif
        }
        hF = clock();
        tempo_total = ((double)(hF - hI))/CLOCKS_PER_SEC;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8a8, %rsp            # imm = 0x8A8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, (%rsp)
leaq 0x1e20(%rip), %rdi      # 0x55c4
callq 0x21b0
callq 0x20b0
movq %rax, %r12
movq %r15, %rdi
callq 0x38af
movq %r15, %rdi
callq 0x38ec
movq %r15, %rdi
callq 0x3bba
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x185a(%rip), %xmm0     # 0x5038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x18e2(%rip), %r13      # 0x50d3
movq %r13, %rdi
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
leaq 0xc(%rsp), %rbp
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x389d
movl $0x89c, %edx            # imm = 0x89C
movq %rbp, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rbp, %rdi
callq 0x39a2
movq %rbp, %rdi
callq 0x3bba
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x3883
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %rbp, %rsi
callq 0x20d0
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x17cb(%rip), %xmm0     # 0x5038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
movq %r13, %rdi
movb $0x1, %al
callq 0x2050
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0x17a0(%rip), %xmm0     # 0x5038
jmp 0x3805
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: calcFO(tSolucao&)
void calcFO(Solucao &s)
{
    memset(&s.vetPesMoc, 0, sizeof(s.vetPesMoc));
    s.funObj = 0;
    for(int j = 0; j < numObj; j++)
        if(s.vetIdMocObj[j] != -1)
        {
            s.funObj += vetValObj[j];
            s.vetPesMoc[s.vetIdMocObj[j]] += vetPesObj[j];
        }
    for(int i = 0; i < numMoc; i++)
        s.funObj -= PESO * MAX(0, s.vetPesMoc[i] - vetCapMoc[i]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2090
andl $0x0, 0x898(%rbx)
movslq 0x4824(%rip), %rax      # 0x8134
leaq 0x4829(%rip), %rcx      # 0x8140
leaq 0x4ff2(%rip), %rdx      # 0x8910
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x3953
cmpl $-0x1, 0xc8(%rbx,%r14)
je 0x394a
movl (%r14,%rcx), %edi
addl %edi, 0x898(%rbx)
movl (%r14,%rdx), %edi
movslq 0xc8(%rbx,%r14), %r8
addl %edi, (%rbx,%r8,4)
incq %rsi
addq $0x4, %r14
jmp 0x3920
movl 0x47df(%rip), %eax      # 0x8138
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl 0x898(%rbx), %edx
shlq $0x2, %rax
leaq 0x576f(%rip), %rsi      # 0x90e0
xorl %edi, %edi
cmpq %rdi, %rax
je 0x399a
movl (%rbx,%rdi), %r8d
subl (%rdi,%rsi), %r8d
imull $-0x64, %r8d, %r9d
testl %r8d, %r8d
cmovsl %ecx, %r9d
addl %r9d, %edx
movl %edx, 0x898(%rbx)
addq $0x4, %rdi
jmp 0x3973
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: gerar_vizinha(tSolucao&)
void gerar_vizinha(Solucao &s)
{
    int obj, moc;
    obj = rand()%numObj;
    do
        moc = rand()%(numMoc+1) - 1;
    while(moc == s.vetIdMocObj[obj]);
    s.vetIdMocObj[obj] = moc;
    calcFO(s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2060
cltd
idivl 0x477f(%rip)            # 0x8134
movslq %edx, %r14
callq 0x2060
movl 0x4775(%rip), %ecx      # 0x8138
incl %ecx
cltd
idivl %ecx
decl %edx
cmpl 0xc8(%rbx,%r14,4), %edx
je 0x39b8
movl %edx, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: procurar_lista(int**, int, int, int)
int procurar_lista(int **lista, const int qtd, const int o, const int m)
{
    for(int i = 0; i < qtd; i++)
        if((lista[0][i] == o) && (lista[1][i] == m))
            return i;
    return -1;
}

// Assembly:
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
pushq $-0x1
popq %rax
cmpq %r8, %rsi
je 0x3a17
movq (%rdi), %r9
cmpl %edx, (%r9,%r8,4)
jne 0x3a0f
movq 0x8(%rdi), %r9
cmpl %ecx, (%r9,%r8,4)
je 0x3a14
incq %r8
jmp 0x39f7
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: remover_lista(int**, int&, int)
void remover_lista(int **lista, int &qtd, const int pos)
{
    for(int i = pos+1; i < qtd; i++)
    {
        lista[0][i-1] = lista[0][i];
        lista[1][i-1] = lista[1][i];
    }
    qtd--;
}

// Assembly:
movslq %edx, %rax
incq %rax
movslq (%rsi), %rcx
cmpq %rcx, %rax
jge 0x3a3d
movq (%rdi), %rcx
movl (%rcx,%rax,4), %edx
movl %edx, -0x4(%rcx,%rax,4)
movq 0x8(%rdi), %rcx
movl (%rcx,%rax,4), %edx
movl %edx, -0x4(%rcx,%rax,4)
jmp 0x3a1b
decl %ecx
movl %ecx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: inserir_lista(int**, int&, int, int, int)
void inserir_lista(int **lista, int &qtd, const int tam, const int o, const int m)
{
    if(qtd == tam)
        remover_lista(lista, qtd, 0); // FIFO
    lista[0][qtd] = o;
    lista[1][qtd] = m;
    qtd++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cmpl %edx, %eax
jne 0x3a6a
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3a18
movl (%r14), %eax
movq (%r15), %rcx
cltq
movl %ebp, (%rcx,%rax,4)
movq 0x8(%r15), %rax
movslq (%r14), %rcx
movl %ebx, (%rax,%rcx,4)
incl (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: heuConAleGul(tSolucao&, int)
void heuConAleGul(Solucao &s, const int percentual)
{
    int tam, pos, aux;
    int vetAux[MAX_OBJ];
    memcpy(&vetAux, &vetIndObjOrd, sizeof(vetIndObjOrd));
    tam = MAX(1, (percentual / 100.0) * numObj);
    for(int j = 0; j < tam; j++)
    {
        pos = j + rand()%(numObj - j);
        aux = vetAux[pos];
        vetAux[pos] = vetAux[j];
        vetAux[j] = aux;
    }
    memset(&s.vetPesMoc, 0, sizeof(s.vetPesMoc));
    memset(&s.vetIdMocObj, -1, sizeof(s.vetIdMocObj));
    for(int j = 0; j < numObj; j++)
        for(int i = 0; i < numMoc; i++)
            if(s.vetPesMoc[i] + vetPesObj[vetAux[j]] <= vetCapMoc[i])
            {
                s.vetIdMocObj[vetAux[j]] = i;
                s.vetPesMoc[i] += vetPesObj[vetAux[j]];
                break;
            }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5709(%rip), %rsi      # 0x91b0
movq %rsp, %rdi
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x20d0
cvtsi2sd %ebp, %xmm0
divsd 0x1580(%rip), %xmm0     # 0x5040
movl 0x466d(%rip), %r14d     # 0x8134
cvtsi2sd %r14d, %xmm1
mulsd %xmm0, %xmm1
movsd 0x1570(%rip), %xmm0     # 0x5048
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x3b22
callq 0x2060
movl 0x4635(%rip), %r14d     # 0x8134
leal (%r12,%r14), %ecx
cltd
idivl %ecx
movslq %edx, %rax
addq %r13, %rax
movl (%rsp,%rax,4), %ecx
movl (%rsp,%r13,4), %edx
movl %edx, (%rsp,%rax,4)
movl %ecx, (%rsp,%r13,4)
incq %r13
decl %r12d
jmp 0x3aee
xorl %r15d, %r15d
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2090
leaq 0xc8(%rbx), %rdi
movl $0x7d0, %edx            # imm = 0x7D0
movl $0xff, %esi
callq 0x2090
movl 0x45e8(%rip), %eax      # 0x8138
testl %eax, %eax
cmovlel %r15d, %eax
testl %r14d, %r14d
cmovlel %r15d, %r14d
leaq 0x557c(%rip), %rcx      # 0x90e0
leaq 0x4da5(%rip), %rdx      # 0x8910
cmpq %r14, %r15
je 0x3ba8
movq %rcx, %rdi
xorl %esi, %esi
cmpq %rsi, %rax
je 0x3ba3
movslq (%rsp,%r15,4), %r8
movl (%rdx,%r8,4), %r9d
movl (%rbx,%rsi,4), %r10d
addl %r9d, %r10d
cmpl (%rdi), %r10d
jle 0x3b97
incq %rsi
addq $0x4, %rdi
jmp 0x3b75
movl %esi, 0xc8(%rbx,%r8,4)
addl %r9d, (%rbx,%rsi,4)
incq %r15
jmp 0x3b6b
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: heuBLPM(tSolucao&)
void heuBLPM(Solucao &s)
{
    int vetObjAux[MAX_OBJ]; // usado para evitar determinismo na ordem de teste dos objetos
    int mocOri, foOri, indice, aux;
    int melFO = s.funObj;
    for(int j = 0; j < numObj; j++)
        vetObjAux[j] = j;
    INICIO : ;
    foOri = s.funObj;
    for(int j = 0; j < numObj; j++)
    {
        indice = j + rand()%(numObj - j);
        mocOri = s.vetIdMocObj[vetObjAux[indice]];
        for(int i = -1; i < numMoc; i++)
        {
            if(i != mocOri)
            {
                s.vetIdMocObj[vetObjAux[indice]] = i;
                calcFO(s);
                if(s.funObj > melFO)
                {
                    melFO = s.funObj;
                    goto INICIO;
                }
                else
                {
                    s.vetIdMocObj[vetObjAux[indice]] = mocOri;
                    s.funObj = foOri;
                }
            }
        }
        aux = vetObjAux[j];
        vetObjAux[j] = vetObjAux[indice];
        vetObjAux[indice] = aux;
    }
    calcFO(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7f8, %rsp            # imm = 0x7F8
movq %rdi, %rbx
movl 0x898(%rdi), %ebp
movl 0x455a(%rip), %edx      # 0x8134
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x3bf4
movl %eax, 0x20(%rsp,%rax,4)
incq %rax
jmp 0x3be6
xorl %r14d, %r14d
movslq %edx, %rax
cmpq %rax, %r14
jge 0x3cb0
callq 0x2060
movl 0x4526(%rip), %ecx      # 0x8134
movl %ecx, 0x8(%rsp)
subl %r14d, %ecx
cltd
idivl %ecx
movq %r14, 0x18(%rsp)
addl %r14d, %edx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rsp,%rax,4), %eax
movl %eax, 0xc(%rsp)
movslq %eax, %r14
movl 0xc8(%rbx,%r14,4), %r13d
movl 0x44f6(%rip), %r15d     # 0x8138
pushq $-0x1
popq %r12
cmpl %r15d, %r12d
jge 0x3c7d
cmpl %r12d, %r13d
je 0x3c78
movl %r12d, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
callq 0x38ec
movl 0x898(%rbx), %eax
cmpl %ebp, %eax
jg 0x3ca5
movl %r13d, 0xc8(%rbx,%r14,4)
movl %ebp, 0x898(%rbx)
incl %r12d
jmp 0x3c46
movq 0x18(%rsp), %r14
movl 0x20(%rsp,%r14,4), %eax
movl 0xc(%rsp), %ecx
movl %ecx, 0x20(%rsp,%r14,4)
movq 0x10(%rsp), %rcx
movl %eax, 0x20(%rsp,%rcx,4)
incq %r14
movl 0x8(%rsp), %edx
jmp 0x3bf7
movl %eax, %ebp
movl 0x8(%rsp), %edx
jmp 0x3bf4
movq %rbx, %rdi
addq $0x7f8, %rsp            # imm = 0x7F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: ordenar_populacao(int)
void ordenar_populacao(const int limite)
{
    int flag;
    Solucao aux;
    flag = 1;
    while(flag)
    {
        flag = 0;
        for(int i = 0; i < limite-1;i++)
        {
            if(vet_populacao[i].funObj < vet_populacao[i+1].funObj)
            {
                flag = 1;
                memcpy(&aux, &vet_populacao[i], sizeof(vet_populacao[i]));
                memcpy(&vet_populacao[i], &vet_populacao[i+1], sizeof(vet_populacao[i+1]));
                memcpy(&vet_populacao[i+1], &aux, sizeof(aux));
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8a8, %rsp            # imm = 0x8A8
decl %edi
xorl %r12d, %r12d
testl %edi, %edi
cmovgl %edi, %r12d
incq %r12
pushq $0x1
popq %rax
leaq 0x5c8e(%rip), %r13      # 0x9980
leaq 0xc(%rsp), %rbx
testl %eax, %eax
je 0x3d65
xorl %ebp, %ebp
xorl %eax, %eax
imulq $0x89c, %rbp, %rcx      # imm = 0x89C
addq %r13, %rcx
incq %rbp
leaq 0x89c(%rcx), %r14
cmpq %rbp, %r12
je 0x3cf7
movl 0x898(%rcx), %edx
cmpl 0x1134(%rcx), %edx
movq %r14, %rcx
jge 0x3d09
leaq -0x89c(%r14), %r15
movl $0x89c, %edx            # imm = 0x89C
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r14, %rsi
callq 0x20d0
movl $0x89c, %edx            # imm = 0x89C
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20d0
pushq $0x1
popq %rax
jmp 0x3cff
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq