LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::not_()
pair<Token*, function<Token*(Token*)>> Evaluator::not_() {
    Token* op = new UnaryOperator(UnaryOperatorType::NOT);
    Token* var1 = new Variable("Pattern");
    List* signature = new List();
    signature->list.push_back(op);
    signature->list.push_back(var1);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            List* list = static_cast<List*>(input);

            Token* pattern_token = this->eval(list->list[1]);
            if (pattern_token->type != TokenType::BOOLEAN) {
                Token* t = new Error("expect a boolean, got:" + pattern_token->debug(), input);
                return t;
            }

            Boolean* pattern = static_cast<Boolean*>(pattern_token);


            Token* res = new Boolean(!pattern->value);
            return res;
    });

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x8, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
xorl %esi, %esi
callq 0x117f0
jmp 0x498f
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x28, %edi
callq 0x32b0
movq %rax, -0xb0(%rbp)
movb $0x1, -0x52(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x34a0
movq -0xa8(%rbp), %rdx
leaq 0x1e9b2(%rip), %rsi     # 0x2337f
leaq -0x50(%rbp), %rdi
callq 0x33b0
jmp 0x49d8
movq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11830
jmp 0x49ea
movb $0x0, -0x52(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
leaq -0x51(%rbp), %rdi
callq 0x3300
movq -0xb0(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x11870
jmp 0x4a29
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x118b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x118b0
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4b30
movq -0xa0(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x4b60
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x32c0
jmp 0x4b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
leaq -0x51(%rbp), %rdi
callq 0x3300
testb $0x1, -0x52(%rbp)
jne 0x4af1
jmp 0x4b02
movq -0xb0(%rbp), %rdi
movl $0x28, %esi
callq 0x32c0
jmp 0x4b21
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x32c0
movq -0x20(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::clear()
pair<Token*, function<Token*(Token*)>> Evaluator::clear() {
    Token* op = new Atom("clear");
    List* signature = new List();
    signature->list.push_back(op);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            clrscr();
           return nullptr;
    });

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x28, %edi
callq 0x32b0
movq %rax, -0x88(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x34a0
movq -0x80(%rbp), %rdx
leaq 0x1c75d(%rip), %rsi     # 0x23379
leaq -0x38(%rbp), %rdi
callq 0x33b0
jmp 0x6c27
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11960
jmp 0x6c39
movb $0x0, -0x4d(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3300
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x11870
jmp 0x6c78
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x118b0
movq -0x90(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6d50
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x6d80
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6cff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3300
testb $0x1, -0x4d(%rbp)
jne 0x6d10
jmp 0x6d21
movq -0x88(%rbp), %rdi
movl $0x28, %esi
callq 0x32c0
jmp 0x6d40
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x20, %esi
callq 0x32c0
movq -0x48(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x28, %edi
callq 0x32b0
movq %rax, -0x88(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x34a0
movq -0x80(%rbp), %rdx
leaq 0x1becc(%rip), %rsi     # 0x233a8
leaq -0x38(%rbp), %rdi
callq 0x33b0
jmp 0x74e7
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11960
jmp 0x74f9
movb $0x0, -0x4d(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3300
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x11870
jmp 0x7538
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x118b0
movq -0x90(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7610
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x7640
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x75bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3300
testb $0x1, -0x4d(%rbp)
jne 0x75d0
jmp 0x75e1
movq -0x88(%rbp), %rdi
movl $0x28, %esi
callq 0x32c0
jmp 0x7600
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x20, %esi
callq 0x32c0
movq -0x48(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x11c20
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7a1d
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11c70
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x79d3
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x11c40
jmp 0x79fb
jmp 0x7b0c
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x11b90
jmp 0x7b32
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x7b0a
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x11a60
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x7b08
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movq -0x68(%rbp), %rsi
callq 0x11a80
movq (%rax), %rax
cmpl $0x3, (%rax)
jne 0x7af5
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movq -0x68(%rbp), %rsi
callq 0x11a80
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movq -0x68(%rbp), %rsi
callq 0x11a80
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x11c70
movq %rdx, -0xb8(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x7acb
movq -0x90(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x11c40
jmp 0x7af3
jmp 0x7af5
jmp 0x7af7
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x7a42
jmp 0x7b0a
jmp 0x7b0c
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x7b22
movq -0x90(%rbp), %rdi
callq 0x11b90
movq -0x88(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x180b0
movq -0x68(%rbp), %rdi
movl $0x0, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x180d0
movq %rax, -0x60(%rbp)
jmp 0x15664
movq -0x60(%rbp), %rdi
leaq 0xdefe(%rip), %rsi      # 0x2356d
callq 0x33a0
jmp 0x15676
movl $0x1, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x180d0
movq %rax, -0x80(%rbp)
jmp 0x15690
movq -0x80(%rbp), %rdi
leaq 0xded6(%rip), %rsi      # 0x23571
callq 0x33a0
jmp 0x156a2
leaq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x181b0
movq %rax, -0x88(%rbp)
jmp 0x156b8
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x3140
jmp 0x156ca
leaq -0x40(%rbp), %rdi
callq 0x18290
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18290
movq -0x50(%rbp), %rdi
callq 0x3490
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x182b0
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x34a0
movq -0xa0(%rbp), %rdx
leaq 0xde30(%rip), %rsi      # 0x2356d
leaq -0x58(%rbp), %rdi
callq 0x33b0
jmp 0x15748
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x182d0
movq %rax, -0xb0(%rbp)
jmp 0x1575e
movq -0xb0(%rbp), %rax
movl $0x0, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x31c0
leaq -0x59(%rbp), %rdi
callq 0x3300
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x34a0
movq -0xb8(%rbp), %rdx
leaq 0xddd3(%rip), %rsi      # 0x23571
leaq -0x90(%rbp), %rdi
callq 0x33b0
jmp 0x157ac
leaq -0x38(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x182d0
movq %rax, -0xc0(%rbp)
jmp 0x157c5
movq -0xc0(%rbp), %rax
movl $0x1, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0x91(%rbp), %rdi
callq 0x3300
movq -0xa8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x183b0
movq %rax, -0xc8(%rbp)
jmp 0x15803
movq -0xc8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xcc(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x18490
movl -0xcc(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1584d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31c0
leaq -0x59(%rbp), %rdi
callq 0x3300
jmp 0x15898
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1587e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0x91(%rbp), %rdi
callq 0x3300
jmp 0x15898
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x18490
movq -0x68(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x184b0
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x34a0
movq -0xc0(%rbp), %rdx
leaq 0xdc80(%rip), %rsi      # 0x2356d
leaq -0x60(%rbp), %rdi
callq 0x33b0
jmp 0x158f8
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x184d0
movq %rax, -0xd0(%rbp)
jmp 0x1590e
movq -0xd0(%rbp), %rax
movb $0x1, (%rax)
leaq -0x60(%rbp), %rdi
callq 0x31c0
leaq -0x61(%rbp), %rdi
callq 0x3300
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x34a0
movq -0xd8(%rbp), %rdx
leaq 0xdc26(%rip), %rsi      # 0x23571
leaq -0x98(%rbp), %rdi
callq 0x33b0
jmp 0x15959
leaq -0x40(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x184d0
movq %rax, -0xe0(%rbp)
jmp 0x15972
movq -0xe0(%rbp), %rax
movb $0x1, (%rax)
leaq -0x98(%rbp), %rdi
callq 0x31c0
leaq -0x99(%rbp), %rdi
callq 0x3300
movq -0xc8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x185b0
movq %rax, -0xe8(%rbp)
jmp 0x159ad
movq -0xe8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18610
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x185e0
testb $0x1, %al
jne 0x159e7
jmp 0x15a6d
movb $0x0, -0x1(%rbp)
movl $0x1, -0xb4(%rbp)
jmp 0x15a9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x15a1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31c0
leaq -0x61(%rbp), %rdi
callq 0x3300
jmp 0x15ab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x15a51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x31c0
leaq -0x99(%rbp), %rdi
callq 0x3300
jmp 0x15ab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x15ab5
movq -0xc8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x18640
movq %rax, -0xf0(%rbp)
jmp 0x15a86
movq -0xf0(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0xb4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18720
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x18720
movq -0x70(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x18740
movq -0x80(%rbp), %rdi
movl $0x1, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x18760
movq %rax, -0x78(%rbp)
jmp 0x15b1a
movq -0x78(%rbp), %rdi
leaq 0xda50(%rip), %rsi      # 0x23575
callq 0x33a0
jmp 0x15b2c
movl $0x0, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18760
movq %rax, -0x98(%rbp)
jmp 0x15b49
movq -0x98(%rbp), %rdi
leaq 0xda20(%rip), %rsi      # 0x23577
callq 0x33a0
jmp 0x15b5e
movl $0x3, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x18760
movq %rax, -0xa0(%rbp)
jmp 0x15b7b
movq -0xa0(%rbp), %rdi
leaq 0xd9f0(%rip), %rsi      # 0x23579
callq 0x33a0
jmp 0x15b90
movl $0x2, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x18760
movq %rax, -0xa8(%rbp)
jmp 0x15bad
movq -0xa8(%rbp), %rdi
leaq 0xd9c0(%rip), %rsi      # 0x2357b
callq 0x33a0
jmp 0x15bc2
movl $0x5, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x18760
movq %rax, -0xb0(%rbp)
jmp 0x15bdf
movq -0xb0(%rbp), %rdi
leaq 0xd990(%rip), %rsi      # 0x2357d
callq 0x33a0
jmp 0x15bf4
movl $0x6, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x18760
movq %rax, -0xb8(%rbp)
jmp 0x15c11
movq -0xb8(%rbp), %rdi
leaq 0xd962(%rip), %rsi      # 0x23581
callq 0x33a0
jmp 0x15c26
movl $0x4, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x18760
movq %rax, -0xc0(%rbp)
jmp 0x15c43
movq -0xc0(%rbp), %rdi
leaq 0xd933(%rip), %rsi      # 0x23584
callq 0x33a0
jmp 0x15c58
movl $0x7, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x18760
movq %rax, -0xc8(%rbp)
jmp 0x15c75
movq -0xc8(%rbp), %rdi
leaq 0xd905(%rip), %rsi      # 0x23588
callq 0x33a0
jmp 0x15c8a
leaq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x18840
movq %rax, -0xd0(%rbp)
jmp 0x15ca0
movq -0xd0(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x3140
jmp 0x15cb5
leaq -0x40(%rbp), %rdi
callq 0x18920
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18920
movq -0x50(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x18d50
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x1719a
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x34a0
movq -0x60(%rbp), %rdx
leaq 0xc5c6(%rip), %rsi      # 0x23657
leaq -0x30(%rbp), %rdi
callq 0x33b0
jmp 0x1709c
leaq -0x31(%rbp), %rdi
callq 0x3300
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18d70
movl (%rax), %eax
movq %rax, -0x68(%rbp)
subq $0x4, %rax
ja 0x1716e
movq -0x68(%rbp), %rax
leaq 0xc443(%rip), %rcx      # 0x23510
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3300
jmp 0x171b1
leaq 0xc4ae(%rip), %rsi      # 0x235a5
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x17102
jmp 0x1716e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31c0
jmp 0x171b1
leaq 0xc482(%rip), %rsi      # 0x235a7
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x17130
jmp 0x1716e
leaq 0xc24e(%rip), %rsi      # 0x23387
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x17144
jmp 0x1716e
leaq 0xc45c(%rip), %rsi      # 0x235a9
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x17158
jmp 0x1716e
leaq 0xc44a(%rip), %rsi      # 0x235ab
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x1716c
jmp 0x1716e
movq 0x1ce53(%rip), %rdi     # 0x33fc8
leaq -0x30(%rbp), %rsi
callq 0x3280
jmp 0x17180
leaq -0x30(%rbp), %rdi
callq 0x31c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x17058
movq 0x1ce27(%rip), %rdi     # 0x33fc8
movl $0xa, %esi
callq 0x3320
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: grmauri[P]pmm/pmm.cpp
// Function: lerDados(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void lerDados(string arq)
{
    FILE *f = fopen(arq.c_str(), "r");
    fscanf(f,"%d %d", &numObj, &numMoc);
    for(int j = 0; j < numObj; j++)
        fscanf(f, "%d", &vetValObj[j]);
    for(int j = 0; j < numObj; j++)
        fscanf(f, "%d", &vetPesObj[j]);
    for(int i = 0; i < numMoc; i++)
        fscanf(f, "%d", &vetCapMoc[i]);
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x20a0
movq %rax, %rdi
leaq 0x3eeb(%rip), %rsi      # 0x71b6
callq 0x21d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3ed9(%rip), %rsi      # 0x71b8
leaq 0x6ebe(%rip), %rdx      # 0xa1a4
leaq 0x6ebb(%rip), %rcx      # 0xa1a8
movb $0x0, %al
callq 0x22d0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x6ea0(%rip), %eax      # 0xa1a4
jge 0x3335
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x6e9b(%rip), %rdx      # 0xa1b0
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x3e98(%rip), %rsi      # 0x71bb
movb $0x0, %al
callq 0x22d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32fb
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x6e5f(%rip), %eax      # 0xa1a4
jge 0x3376
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq 0x762a(%rip), %rdx      # 0xa980
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x3e57(%rip), %rsi      # 0x71bb
movb $0x0, %al
callq 0x22d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x333c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x6e22(%rip), %eax      # 0xa1a8
jge 0x33b7
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0x7db9(%rip), %rdx      # 0xb150
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x3e16(%rip), %rsi      # 0x71bb
movb $0x0, %al
callq 0x22d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x337d
movq -0x10(%rbp), %rdi
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x6dc0(%rip), %eax      # 0xa1a4
jge 0x3402
movl -0xc(%rbp), %edx
movslq -0xc(%rbp), %rcx
leaq 0x7e2c(%rip), %rax      # 0xb220
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x33db
movl $0x1, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x351d
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x6d7a(%rip), %ecx      # 0xa1a4
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3518
movslq -0x10(%rbp), %rcx
leaq 0x7de0(%rip), %rax      # 0xb220
movslq (%rax,%rcx,4), %rcx
leaq 0x6d65(%rip), %rax      # 0xa1b0
cvtsi2sdl (%rax,%rcx,4), %xmm1
movslq -0x10(%rbp), %rcx
leaq 0x7dc5(%rip), %rax      # 0xb220
movslq (%rax,%rcx,4), %rcx
leaq 0x751a(%rip), %rax      # 0xa980
cvtsi2sdl (%rax,%rcx,4), %xmm0
divsd %xmm0, %xmm1
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x7da1(%rip), %rax      # 0xb220
movslq (%rax,%rcx,4), %rcx
leaq 0x6d26(%rip), %rax      # 0xa1b0
cvtsi2sdl (%rax,%rcx,4), %xmm0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x7d81(%rip), %rax      # 0xb220
movslq (%rax,%rcx,4), %rcx
leaq 0x74d6(%rip), %rax      # 0xa980
cvtsi2sdl (%rax,%rcx,4), %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3508
movl $0x1, -0x4(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x7d55(%rip), %rax      # 0xb220
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x7d3f(%rip), %rax      # 0xb220
movl (%rax,%rcx,4), %edx
movslq -0x10(%rbp), %rcx
leaq 0x7d31(%rip), %rax      # 0xb220
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edx
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x7d1b(%rip), %rax      # 0xb220
movl %edx, (%rax,%rcx,4)
jmp 0x350a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3421
jmp 0x3409
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x8e0, %rsp            # imm = 0x8E0
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x3407(%rip), %rdi      # 0x70fd
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl $0x80000001, 0x898(%rax) # imm = 0x80000001
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3e05
movl -0x4(%rbp), %esi
leaq -0x8d4(%rbp), %rdi
callq 0x49e0
leaq -0x8d4(%rbp), %rdi
callq 0x46f0
leaq -0x8d4(%rbp), %rdi
callq 0x4c30
movl -0x3c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x898(%rcx), %eax
jle 0x3dd6
movq -0x18(%rbp), %rdi
leaq -0x8d4(%rbp), %rsi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x3286(%rip), %xmm1     # 0x7030
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movl 0x898(%rax), %esi
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x32ff(%rip), %rdi      # 0x70ce
movb $0x1, %al
callq 0x2050
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x323c(%rip), %xmm1     # 0x7030
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x3d2a
addq $0x8e0, %rsp            # imm = 0x8E0
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x2c3f(%rip), %rdi      # 0x7152
movb $0x0, %al
callq 0x2050
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4690
movq -0x10(%rbp), %rdi
callq 0x46f0
movq -0x10(%rbp), %rdi
callq 0x4c30
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x2ad4(%rip), %xmm1     # 0x7030
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movl 0x898(%rax), %esi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x2b4d(%rip), %rdi      # 0x70ce
movb $0x1, %al
callq 0x2050
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4679
movq -0x10(%rbp), %rsi
leaq -0x8cc(%rbp), %rdi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
leaq -0x8cc(%rbp), %rdi
callq 0x4810
leaq -0x8cc(%rbp), %rdi
callq 0x4c30
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x898(%rcx), %eax
jle 0x464a
movq -0x10(%rbp), %rdi
leaq -0x8cc(%rbp), %rsi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x2a12(%rip), %xmm1     # 0x7030
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movl 0x898(%rax), %esi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x2a8b(%rip), %rdi      # 0x70ce
movb $0x1, %al
callq 0x2050
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x29c8(%rip), %xmm1     # 0x7030
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x4598
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movq -0x8(%rbp), %rax
movl $0x0, 0x898(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x5a7a(%rip), %eax      # 0xa1a4
jge 0x4791
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0xc8(%rax,%rcx,4)
je 0x4784
movslq -0xc(%rbp), %rcx
leaq 0x5a67(%rip), %rax      # 0xa1b0
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
addl 0x898(%rax), %ecx
movl %ecx, 0x898(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x6219(%rip), %rax      # 0xa980
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rsi
movslq 0xc8(%rcx,%rsi,4), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x4786
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4721
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x5a07(%rip), %eax      # 0xa1a8
jge 0x4808
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0x10(%rbp), %rdx
leaq 0x6997(%rip), %rax      # 0xb150
subl (%rax,%rdx,4), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x47c9
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x47e5
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0x10(%rbp), %rdx
leaq 0x6971(%rip), %rcx      # 0xb150
subl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
imull $0x64, %eax, %edx
movq -0x8(%rbp), %rax
movl 0x898(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x898(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4798
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2070
cltd
idivl 0x597c(%rip)            # 0xa1a4
movl %edx, -0xc(%rbp)
callq 0x2070
movl 0x5972(%rip), %ecx      # 0xa1a8
addl $0x1, %ecx
cltd
idivl %ecx
subl $0x1, %edx
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
cmpl 0xc8(%rcx,%rdx,4), %eax
je 0x482b
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x46f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x48dc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x48cf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x48cf
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e3
jmp 0x48d1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4898
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4962
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4908
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x49a4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x48f0
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x8b0, %rsp            # imm = 0x8B0
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x4f81
movl $0x0, -0x8(%rbp)
movl $0x0, -0x8a8(%rbp)
movl -0x8a8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4f7c
movslq -0x8a8(%rbp), %rcx
leaq 0x6b5e(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movl 0x898(%rax), %eax
movl -0x8a8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x6b3b(%rip), %rcx      # 0xb9f0
imulq $0x89c, %rdx, %rdx      # imm = 0x89C
addq %rdx, %rcx
cmpl 0x898(%rcx), %eax
jge 0x4f66
movl $0x1, -0x8(%rbp)
movslq -0x8a8(%rbp), %rax
leaq 0x6b10(%rip), %rsi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rsi
leaq -0x8a4(%rbp), %rdi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
movslq -0x8a8(%rbp), %rax
leaq 0x6ae7(%rip), %rdi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rdi
movl -0x8a8(%rbp), %eax
addl $0x1, %eax
cltq
leaq 0x6acb(%rip), %rsi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rsi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
movl -0x8a8(%rbp), %eax
addl $0x1, %eax
cltq
leaq 0x6aa5(%rip), %rdi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rdi
leaq -0x8a4(%rbp), %rsi
movl $0x89c, %edx            # imm = 0x89C
callq 0x2140
jmp 0x4f68
movl -0x8a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8a8(%rbp)
jmp 0x4e70
jmp 0x4e55
addq $0x8b0, %rsp            # imm = 0x8B0
popq %rbp
retq
nopw (%rax,%rax)
// File: grmauri[P]pmm/pmm.cpp
// Function: crossover(int, int, int, int)
void crossover(const int p1, const int p2, const int f1, const int f2)
{
    int p = 1 + rand()%(numObj-1);
    for(int i = 0; i < p; i++)
    {
        vet_populacao[f1].vetIdMocObj[i] = vet_populacao[p1].vetIdMocObj[i];
        vet_populacao[f2].vetIdMocObj[i] = vet_populacao[p2].vetIdMocObj[i];
    }
    for(int i = p; i < numObj; i++)
    {
        vet_populacao[f1].vetIdMocObj[i] = vet_populacao[p2].vetIdMocObj[i];
        vet_populacao[f2].vetIdMocObj[i] = vet_populacao[p1].vetIdMocObj[i];
    }
    calcFO(vet_populacao[f1]);
    calcFO(vet_populacao[f2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
callq 0x2070
movl 0x51f5(%rip), %ecx      # 0xa1a4
subl $0x1, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x505c
movslq -0x4(%rbp), %rcx
leaq 0x6a17(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
leaq 0x69f7(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x69d7(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %edx
movslq -0x10(%rbp), %rcx
leaq 0x69b7(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4fc2
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x5139(%rip), %eax      # 0xa1a4
jge 0x50ff
movslq -0x8(%rbp), %rcx
leaq 0x6974(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
leaq 0x6954(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x6934(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %edx
movslq -0x10(%rbp), %rcx
leaq 0x6914(%rip), %rax      # 0xb9f0
imulq $0x89c, %rcx, %rcx      # imm = 0x89C
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5062
movslq -0xc(%rbp), %rax
leaq 0x68e6(%rip), %rdi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rdi
callq 0x46f0
movslq -0x10(%rbp), %rax
leaq 0x68cc(%rip), %rdi      # 0xb9f0
imulq $0x89c, %rax, %rax      # imm = 0x89C
addq %rax, %rdi
callq 0x46f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: grmauri[P]pmm/pmm.cpp
// Function: gerar_vizinha2(tSolucao&)
void gerar_vizinha2(Solucao &s)
{
    int obj1, obj2, aux;
    obj1 = rand()%numObj;
    do
        obj2 = rand()%numObj;
    while(s.vetIdMocObj[obj2] == s.vetIdMocObj[obj1]);
    aux = s.vetIdMocObj[obj1];
    s.vetIdMocObj[obj1] = s.vetIdMocObj[obj2];
    s.vetIdMocObj[obj2] = aux;
    calcFO(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2070
cltd
idivl 0x504c(%rip)            # 0xa1a4
movl %edx, -0xc(%rbp)
callq 0x2070
cltd
idivl 0x503d(%rip)            # 0xa1a4
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
cmpl 0xc8(%rcx,%rdx,4), %eax
je 0x515b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x46f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: grmauri[P]pmm/pmm.cpp
// Function: heuBLRA(tSolucao&, int)
void heuBLRA(Solucao &s, const int iteracoes)
{
    int obj, moc, mocOri, foOri, flag;
    int melFO = s.funObj;
    while(true)
    {
        flag = 1;
        for(int t = 0; t < iteracoes; t++)
        {
            foOri = s.funObj;
            obj = rand()%numObj;
            do
                moc = rand()%(numMoc + 1) - 1;
            while(moc == s.vetIdMocObj[obj]);
            mocOri = s.vetIdMocObj[obj];
            s.vetIdMocObj[obj] = moc;
            calcFO(s);
            if(s.funObj > melFO)
            {
                melFO = s.funObj;
                flag = 0;
            }
            else
            {
                s.vetIdMocObj[obj] = mocOri;
                s.funObj = foOri;
            }
        }
        if(flag)
            break;
    }
    calcFO(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x52de
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x2070
cltd
idivl 0x4f75(%rip)            # 0xa1a4
movl %edx, -0x10(%rbp)
callq 0x2070
movl 0x4f6b(%rip), %ecx      # 0xa1a8
addl $0x1, %ecx
cltd
idivl %ecx
subl $0x1, %edx
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
cmpl 0xc8(%rcx,%rdx,4), %eax
je 0x5232
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x46f0
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
cmpl -0x24(%rbp), %eax
jle 0x52af
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x52ce
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x898(%rax)
jmp 0x52d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x520a
cmpl $0x0, -0x20(%rbp)
je 0x52e6
jmp 0x52eb
jmp 0x51fc
movq -0x8(%rbp), %rdi
callq 0x46f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)