LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl %ecx, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc24c
movq 0x8(%rax), %rdx
leaq 0x4f2a(%rip), %rcx      # 0xf4e8
movl $0x3, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc24c
movq 0x8(%rax), %rdx
leaq 0x4f00(%rip), %rcx      # 0xf4ec
movl $0x3, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xc2b4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3a18
leaq -0x40(%rbp), %rdi
callq 0xc88c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xa639
jmp 0xa639
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc88c
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4e62(%rip), %rsi      # 0xf4e8
leaq 0x4e5e(%rip), %rdx      # 0xf4eb
leaq -0x30(%rbp), %rdi
callq 0x3bb0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc31c
movl $0x0, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xa6be
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31c0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x4e20(%rip), %rsi      # 0xf4ec
leaq 0x4e1c(%rip), %rdx      # 0xf4ef
callq 0x3bb0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc31c
movl $0x1, (%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xa700
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31c0
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0xc39c
movl (%rax), %ebx
leaq -0x60(%rbp), %rdi
callq 0xc91c
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xa742
jmp 0xa728
jmp 0xa742
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xa745
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x31c0
jmp 0xa745
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc91c
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rax, 0x20(%r14)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4d56(%rip), %rsi      # 0xf4e8
leaq 0x4d52(%rip), %rdx      # 0xf4eb
leaq -0x38(%rbp), %rdi
callq 0x3bb0
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc41c
movb $0x1, (%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa7c7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x31c0
leaq -0x38(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x4d17(%rip), %rsi      # 0xf4ec
leaq 0x4d13(%rip), %rdx      # 0xf4ef
callq 0x3bb0
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc41c
movb $0x1, (%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa806
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x31c0
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0xd676
cmpq %r14, %rax
je 0xa827
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0xc49c
movb (%rax), %bl
jmp 0xa829
xorl %ebx, %ebx
leaq -0x68(%rbp), %rdi
callq 0xc9ac
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa843
jmp 0xa85f
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xa862
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x31c0
jmp 0xa862
jmp 0xa85f
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xc9ac
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0x1, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4c34(%rip), %rcx      # 0xf4f0
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4c08(%rip), %rcx      # 0xf4f2
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x3, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4bdc(%rip), %rcx      # 0xf4f4
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4bb0(%rip), %rcx      # 0xf4f6
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x5, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4b84(%rip), %rcx      # 0xf4f8
movl $0x3, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x6, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4b5a(%rip), %rcx      # 0xf4fc
movl $0x2, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4b2f(%rip), %rcx      # 0xf4ff
movl $0x3, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0xc(%rbp), %rsi
movl $0x7, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xc51c
movq 0x8(%rax), %rdx
leaq 0x4b05(%rip), %rcx      # 0xf503
movl $0x1, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x3280
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xc584
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3a18
leaq -0x40(%rbp), %rdi
callq 0xca3c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
jmp 0xaa57
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xca3c
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0xb668
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
xorl %r12d, %r12d
leaq 0x3fc1(%rip), %r14      # 0xf5a8
leaq -0x48(%rbp), %r15
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x3bb0
movq (%rbx), %rax
movl (%rax,%r12,4), %eax
cmpq $0x5, %rax
jae 0xb62c
leaq 0x3ec3(%rip), %rdx      # 0xf4d4
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
movq -0x40(%rbp), %rdx
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3280
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x9995(%rip), %rdi      # 0x14fd0
callq 0x3200
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xb655
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31c0
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rax, %r12
jb 0xb5eb
leaq -0x48(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x995a(%rip), %rdi      # 0x14fd0
movl $0x1, %edx
callq 0x3200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xb6a7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movslq 0x5e14(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x33ce
leal 0x1(%rax), %ecx
andl $-0x2, %ecx
leaq -0x1(%rax), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x2d2b(%rip), %xmm1     # 0x6080
xorl %edx, %edx
movdqa 0x2d31(%rip), %xmm2     # 0x6090
pxor %xmm2, %xmm0
leaq 0x6e56(%rip), %rsi      # 0xa1c0
pcmpeqd %xmm3, %xmm3
movdqa 0x2d2a(%rip), %xmm4     # 0x60a0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edi
notl %edi
testb $0x1, %dil
je 0x33ab
movl %edx, (%rsi,%rdx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x33c1
leal 0x1(%rdx), %edi
movl %edi, 0x4(%rsi,%rdx,4)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x3376
cmpl $0x2, %eax
jl 0x3461
leal -0x1(%rax), %ecx
leaq 0x5d6f(%rip), %rdx      # 0x9150
leaq 0x6538(%rip), %rsi      # 0x9920
leaq 0x6dd1(%rip), %rdi      # 0xa1c0
xorl %r8d, %r8d
movl 0x6dc7(%rip), %r9d      # 0xa1c0
xorl %r10d, %r10d
movslq %r9d, %rbx
movslq 0x4(%rdi,%r8,4), %r11
movss (%rdx,%r11,4), %xmm0
movss (%rdx,%rbx,4), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2pd %xmm1, %xmm0
movd (%rsi,%r11,4), %xmm1
movd (%rsi,%rbx,4), %xmm2
punpckldq %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 0x344c
movl %r11d, (%rdi,%r8,4)
movl %r9d, 0x4(%rdi,%r8,4)
movl $0x1, %r10d
jmp 0x344f
movl %r11d, %r9d
incq %r8
cmpq %r8, %rcx
jne 0x33fc
testl %r10d, %r10d
je 0x3461
cmpl $0x2, %eax
jge 0x33ef
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a2f(%rip), %rdi      # 0x65a2
callq 0x21c0
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
callq 0x20a0
movl $0x80000001, 0x898(%r15) # imm = 0x80000001
movsd (%rsp), %xmm0
ucomisd (%rbx), %xmm0
jbe 0x3c3e
movq %rax, %r12
leaq 0xc(%rsp), %r13
movq %r13, %rdi
movl %ebp, %esi
callq 0x44b1
movq %r13, %rdi
callq 0x42ff
movq %r13, %rdi
callq 0x45db
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x3c13
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r13, %rsi
callq 0x20c0
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x243f(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x24f7(%rip), %rdi      # 0x6103
movb $0x1, %al
callq 0x2050
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x240d(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3ba7
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x8a8, %rsp            # imm = 0x8A8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm0, (%rsp)
leaq 0x25a6(%rip), %rdi      # 0x65d9
callq 0x21c0
callq 0x20a0
movq %rax, %r12
movq %r15, %rdi
callq 0x42bb
movq %r15, %rdi
callq 0x42ff
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1fd0(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x2088(%rip), %rdi      # 0x6103
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x415d
xorl %ebp, %ebp
leaq 0xc(%rsp), %r13
movl $0x89c, %edx            # imm = 0x89C
movq %r13, %rdi
movq %r15, %rsi
callq 0x20c0
movq %r13, %rdi
testl %ebp, %ebp
je 0x40bf
callq 0x4957
jmp 0x40c4
callq 0x43b2
movq %r13, %rdi
callq 0x45db
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x4122
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r13, %rsi
callq 0x20c0
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1f34(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x1fec(%rip), %rdi      # 0x6103
movb $0x1, %al
callq 0x2050
xorl %ebp, %ebp
jmp 0x4124
incl %ebp
cmpl $0x2, %ebp
jl 0x40a1
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1ef3(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movl $0x0, %ebp
ja 0x40a1
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x245f(%rip), %rdi      # 0x65f4
callq 0x21c0
callq 0x20a0
movq %rax, %r12
movq %r15, %rdi
callq 0x42bb
movq %r15, %rdi
callq 0x42ff
movq %r15, %rdi
callq 0x45db
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1e66(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x1f1e(%rip), %rdi      # 0x6103
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x42a9
leaq 0xc(%rsp), %r13
leaq 0x1ef3(%rip), %rbp      # 0x6103
movl $0x89c, %edx            # imm = 0x89C
movq %r13, %rdi
movq %r15, %rsi
callq 0x20c0
movq %r13, %rdi
callq 0x43b2
movq %r13, %rdi
callq 0x45db
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x427e
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r13, %rsi
callq 0x20c0
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1dd0(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
movq %rbp, %rdi
movb $0x1, %al
callq 0x2050
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1da2(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4210
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2080
movl $0x0, 0x898(%rbx)
movslq 0x4e20(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x436e
shlq $0x2, %rax
xorl %ecx, %ecx
leaq 0x4e1a(%rip), %rdx      # 0x9150
leaq 0x55e3(%rip), %rsi      # 0x9920
cmpl $-0x1, 0xc8(%rbx,%rcx)
je 0x435f
movl (%rcx,%rdx), %edi
addl %edi, 0x898(%rbx)
movl (%rcx,%rsi), %edi
movslq 0xc8(%rbx,%rcx), %r8
addl %edi, (%rbx,%r8,4)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x433d
movl 0x898(%rbx), %ebp
movslq 0x4dd3(%rip), %rax      # 0x9148
testq %rax, %rax
jle 0x43ab
shlq $0x2, %rax
xorl %ecx, %ecx
leaq 0x5d69(%rip), %rdx      # 0xa0f0
xorl %esi, %esi
movl (%rbx,%rsi), %edi
subl (%rsi,%rdx), %edi
imull $-0x64, %edi, %r8d
testl %edi, %edi
cmovsl %ecx, %r8d
addl %r8d, %ebp
movl %ebp, 0x898(%rbx)
addq $0x4, %rsi
cmpq %rsi, %rax
jne 0x4389
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d7f(%rip)            # 0x9144
movslq %edx, %r14
callq 0x2060
movl 0x4d75(%rip), %ecx      # 0x9148
incl %ecx
cltd
idivl %ecx
decl %edx
cmpl 0xc8(%rbx,%r14,4), %edx
je 0x43c8
movl %edx, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42ff
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x4424
movq (%rdi), %r8
movl %esi, %r9d
xorl %esi, %esi
cmpl %edx, (%r8,%rsi,4)
jne 0x441c
movq 0x8(%rdi), %r10
cmpl %ecx, (%r10,%rsi,4)
je 0x4425
incq %rsi
cmpq %rsi, %r9
jne 0x440c
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
leal 0x1(%rdx), %eax
movl (%rsi), %r8d
cmpl %r8d, %eax
jge 0x4459
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movslq %edx, %rdx
incq %rdx
movl (%rax,%rdx,4), %edi
movl %edi, -0x4(%rax,%rdx,4)
movl (%rcx,%rdx,4), %edi
movl %edi, -0x4(%rcx,%rdx,4)
incq %rdx
movslq (%rsi), %r8
cmpq %r8, %rdx
jl 0x4440
decl %r8d
movl %r8d, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rsi), %eax
cmpl %edx, %eax
jne 0x449b
cmpl $0x2, %edx
jl 0x4495
movq (%rdi), %rax
movq 0x8(%rdi), %r9
movl $0x1, %r10d
movl (%rax,%r10,4), %edx
movl %edx, -0x4(%rax,%r10,4)
movl (%r9,%r10,4), %edx
movl %edx, -0x4(%r9,%r10,4)
incq %r10
movslq (%rsi), %rdx
cmpq %rdx, %r10
jl 0x4478
decl %edx
movl %edx, (%rsi)
movl %edx, %eax
movq (%rdi), %rdx
cltq
movl %ecx, (%rdx,%rax,4)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movl %r8d, (%rax,%rcx,4)
incl (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cf2(%rip), %rsi      # 0xa1c0
movq %rsp, %rdi
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x20c0
cvtsi2sd %ebp, %xmm0
divsd 0x1b59(%rip), %xmm0     # 0x6040
movl 0x4c56(%rip), %r14d     # 0x9144
cvtsi2sd %r14d, %xmm1
mulsd %xmm0, %xmm1
movsd 0x1b49(%rip), %xmm0     # 0x6048
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
testl %eax, %eax
jle 0x4546
movl %eax, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
callq 0x2060
movl 0x4c24(%rip), %r14d     # 0x9144
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
cmpq %r13, %r15
jne 0x4514
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2080
leaq 0xc8(%rbx), %rdi
movl $0x7d0, %edx            # imm = 0x7D0
movl $0xff, %esi
callq 0x2080
testl %r14d, %r14d
jle 0x45c9
movl 0x4bd2(%rip), %eax      # 0x9148
movl %r14d, %ecx
xorl %edx, %edx
leaq 0x539e(%rip), %rsi      # 0x9920
leaq 0x5b67(%rip), %rdi      # 0xa0f0
testl %eax, %eax
jle 0x45c1
movslq (%rsp,%rdx,4), %r8
movl (%rsi,%r8,4), %r9d
movq %rdi, %r11
xorl %r10d, %r10d
movl (%rbx,%r10,4), %ebp
addl %r9d, %ebp
cmpl (%r11), %ebp
jle 0x45b5
incq %r10
addq $0x4, %r11
cmpq %r10, %rax
jne 0x459b
jmp 0x45c1
movl %r10d, 0xc8(%rbx,%r8,4)
addl %r9d, (%rbx,%r10,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x4589
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, (%rsp)
cmpl $0x2, %edi
jl 0x4820
movq (%rsp), %rax
leal -0x1(%rax), %r13d
xorl %ebx, %ebx
leaq 0x61ea(%rip), %rbp      # 0xa990
leaq 0xc(%rsp), %r14
xorl %eax, %eax
imulq $0x89c, %rbx, %r15      # imm = 0x89C
movl 0x898(%r15,%rbp), %ecx
cmpl 0x1134(%r15,%rbp), %ecx
jge 0x4807
addq %rbp, %r15
movl $0x89c, %eax            # imm = 0x89C
leaq (%r15,%rax), %r12
movl $0x89c, %edx            # imm = 0x89C
movq %r14, %rdi
movq %r15, %rsi
callq 0x20c0
movl $0x89c, %edx            # imm = 0x89C
movq %r15, %rdi
movq %r12, %rsi
callq 0x20c0
movl $0x89c, %edx            # imm = 0x89C
movq %r12, %rdi
movq %r14, %rsi
callq 0x20c0
movl $0x1, %eax
incq %rbx
cmpq %r13, %rbx
jne 0x47ad
testl %eax, %eax
je 0x4820
xorl %ebx, %ebx
movl $0x0, %eax
cmpl $0x2, (%rsp)
jge 0x47ad
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
callq 0x2060
movl 0x48f5(%rip), %ecx      # 0x9144
leal -0x1(%rcx), %esi
cltd
idivl %esi
movslq %ebp, %rax
movslq %ebx, %r12
movslq %r14d, %rdi
movslq %r15d, %rsi
testl %edx, %edx
js 0x48ba
incl %edx
imulq $0x89c, %rsi, %r8       # imm = 0x89C
leaq 0x611b(%rip), %r14      # 0xa990
addq $0xc8, %r14
addq %r14, %r8
imulq $0x89c, %rax, %r9       # imm = 0x89C
addq %r14, %r9
imulq $0x89c, %rdi, %r10      # imm = 0x89C
addq %r14, %r10
imulq $0x89c, %r12, %r11      # imm = 0x89C
addq %r14, %r11
xorl %r14d, %r14d
movl (%r8,%r14,4), %r15d
movl %r15d, (%r9,%r14,4)
movl (%r10,%r14,4), %r15d
movl %r15d, (%r11,%r14,4)
incq %r14
cmpq %r14, %rdx
jne 0x48a0
jmp 0x48bc
incl %edx
subl %edx, %ecx
jle 0x492a
movslq %ebp, %rax
movslq %ebx, %r12
movslq %edx, %r8
imulq $0x89c, %rdi, %rdx      # imm = 0x89C
leaq (%rdx,%r8,4), %rdx
leaq 0x60b5(%rip), %r9       # 0xa990
addq $0xc8, %r9
addq %r9, %rdx
imulq $0x89c, %rax, %rdi      # imm = 0x89C
leaq (%rdi,%r8,4), %rdi
addq %r9, %rdi
imulq $0x89c, %rsi, %rsi      # imm = 0x89C
leaq (%rsi,%r8,4), %rsi
addq %r9, %rsi
imulq $0x89c, %r12, %r10      # imm = 0x89C
leaq (%r10,%r8,4), %r8
addq %r9, %r8
xorl %r9d, %r9d
movl (%rdx,%r9,4), %r10d
movl %r10d, (%rdi,%r9,4)
movl (%rsi,%r9,4), %r10d
movl %r10d, (%r8,%r9,4)
incq %r9
cmpl %r9d, %ecx
jne 0x4912
imulq $0x89c, %rax, %rdi      # imm = 0x89C
leaq 0x6058(%rip), %rbx      # 0xa990
addq %rbx, %rdi
callq 0x42ff
imulq $0x89c, %r12, %rdi      # imm = 0x89C
addq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42ff
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2060
cltd
idivl 0x47da(%rip)            # 0x9144
movslq %edx, %r14
callq 0x2060
cltd
idivl 0x47cb(%rip)            # 0x9144
movslq %edx, %rax
movl 0xc8(%rbx,%rax,4), %ecx
movl 0xc8(%rbx,%r14,4), %edx
cmpl %edx, %ecx
je 0x496d
movl %ecx, 0xc8(%rbx,%r14,4)
movl %edx, 0xc8(%rbx,%rax,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42ff
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, (%rsp)
movq %rdi, %rbx
movl 0x898(%rdi), %eax
movl %eax, %ecx
cmpl $0x0, (%rsp)
jle 0x4a58
movl $0x1, %edx
xorl %r14d, %r14d
movl %edx, 0x4(%rsp)
movl %ecx, %r15d
movl %eax, %r13d
callq 0x2060
cltd
idivl 0x4756(%rip)            # 0x9144
movslq %edx, %rbp
callq 0x2060
movl 0x474c(%rip), %ecx      # 0x9148
incl %ecx
cltd
idivl %ecx
decl %edx
movl 0xc8(%rbx,%rbp,4), %r12d
cmpl %r12d, %edx
je 0x49f1
movl %edx, 0xc8(%rbx,%rbp,4)
movq %rbx, %rdi
callq 0x42ff
movl 0x898(%rbx), %eax
xorl %edx, %edx
movl %eax, %ecx
cmpl %r15d, %eax
jg 0x4a47
movl %r12d, 0xc8(%rbx,%rbp,4)
movl %r13d, 0x898(%rbx)
movl %r13d, %eax
movl 0x4(%rsp), %edx
movl %r15d, %ecx
incl %r14d
cmpl (%rsp), %r14d
jne 0x49d8
testl %edx, %edx
je 0x49c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42ff
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: heuBLMM(tSolucao&)
void heuBLMM(Solucao &s)
{
    int mocOri, foOri, melObj, melMoc, flag;
    int melFO = s.funObj;
    while(true)
    {
        flag = 0;
        foOri = s.funObj;
        for(int j = 0; j < numObj; j++)
        {
            mocOri = s.vetIdMocObj[j];
            for(int i = -1; i < numMoc; i++)
            {
                if(i != mocOri)
                {
                    s.vetIdMocObj[j] = i;
                    calcFO(s);
                    if(s.funObj > melFO)
                    {
                        melFO = s.funObj;
                        melObj = j;
                        melMoc = i;
                        flag = 1;
                    }
                }
            }
            s.vetIdMocObj[j] = mocOri;
            s.funObj = foOri;
        }
        if(flag)
        {
            s.vetIdMocObj[melObj] = melMoc;
            s.funObj = melFO;
        }
        else
            break;
    }
    calcFO(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x46be(%rip), %rcx      # 0x9144
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
jle 0x4b47
movl 0x46ae(%rip), %ebp      # 0x9148
movl 0x898(%rbx), %r13d
movl %r13d, (%rsp)
xorl %r14d, %r14d
movl $0x0, 0x4(%rsp)
movl 0xc8(%rbx,%r14,4), %r12d
testl %ebp, %ebp
js 0x4aff
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl %r15d, %r12d
je 0x4af7
movl %r15d, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
callq 0x42ff
movl 0x898(%rbx), %eax
cmpl %r13d, %eax
jle 0x4af7
movl $0x1, 0x4(%rsp)
movl %r14d, 0xc(%rsp)
movl %r15d, 0x8(%rsp)
movl %eax, %r13d
incl %r15d
cmpl %r15d, %ebp
jne 0x4ac2
movl %r12d, 0xc8(%rbx,%r14,4)
movl (%rsp), %eax
movl %eax, 0x898(%rbx)
incq %r14
cmpq 0x10(%rsp), %r14
jne 0x4ab0
cmpl $0x0, 0x4(%rsp)
je 0x4b47
movslq 0xc(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0xc8(%rbx,%rax,4)
movl %r13d, 0x898(%rbx)
movl %r13d, (%rsp)
cmpl $0x0, 0x10(%rsp)
jg 0x4aa5
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42ff
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: heuConGul(tSolucao&)
void heuConGul(Solucao &s)
{
    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[vetIndObjOrd[j]] <= vetCapMoc[i])
            {
                s.vetIdMocObj[vetIndObjOrd[j]] = i;
                s.vetPesMoc[i] += vetPesObj[vetIndObjOrd[j]];
                break;
            }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2080
leaq 0xc8(%rbx), %rdi
movl $0x7d0, %edx            # imm = 0x7D0
movl $0xff, %esi
callq 0x2080
movslq 0x45b7(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x4bef
movl 0x45b0(%rip), %ecx      # 0x9148
xorl %edx, %edx
leaq 0x561f(%rip), %rsi      # 0xa1c0
leaq 0x4d78(%rip), %rdi      # 0x9920
leaq 0x5541(%rip), %r8       # 0xa0f0
testl %ecx, %ecx
jle 0x4be7
movslq (%rsi,%rdx,4), %r9
movl (%rdi,%r9,4), %r10d
movq %r8, %r14
xorl %r11d, %r11d
movl (%rbx,%r11,4), %ebp
addl %r10d, %ebp
cmpl (%r14), %ebp
jle 0x4bdb
incq %r11
addq $0x4, %r14
cmpq %r11, %rcx
jne 0x4bc1
jmp 0x4be7
movl %r11d, 0xc8(%rbx,%r9,4)
addl %r10d, (%rbx,%r11,4)
incq %rdx
cmpq %rax, %rdx
jne 0x4baf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: escreverSolucao(tSolucao&, bool)
void escreverSolucao(Solucao &s, const bool flag)
{
    printf("\nFO: %d\n", s.funObj);
    if(flag)
    {
        printf("VETOR ID MOCHILAS DE CADA OBJETO: ");
        for(int j = 0; j < numObj; j++)
            printf("%d  ", s.vetIdMocObj[j]);
        printf("\nVETOR PESO MOCHILAS: ");
        for(int i = 0; i < numMoc; i++)
            printf("%d  ", s.vetPesMoc[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x898(%rdi), %esi
leaq 0x150a(%rip), %rdi      # 0x6117
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x4c9c
leaq 0x14fd(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x4513(%rip)      # 0x9144
jle 0x4c5e
leaq 0x1509(%rip), %r14      # 0x6143
xorl %r15d, %r15d
movl 0xc8(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x44eb(%rip), %rax      # 0x9144
cmpq %rax, %r15
jl 0x4c3d
leaq 0x14e3(%rip), %rdi      # 0x6148
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x44d5(%rip)      # 0x9148
jle 0x4c9c
leaq 0x14c7(%rip), %r14      # 0x6143
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x44b1(%rip), %rax      # 0x9148
cmpq %rax, %r15
jl 0x4c7f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: testarDados(char*)
void testarDados(char *arq)
{
    FILE *f;
    if(arq == "")
        f = stdout;
    else
        f = fopen(arq, "w");
    fprintf(f,"%d %d\n", numObj, numMoc);
    for(int j = 0; j < numObj; j++)
        fprintf(f, "%d ", vetValObj[j]);
    fprintf(f,"\n");
    for(int j = 0; j < numObj; j++)
        fprintf(f, "%d ", vetPesObj[j]);
    fprintf(f,"\n");
    for(int i = 0; i < numMoc; i++)
        fprintf(f, "%d ", vetCapMoc[i]);
    if(arq != "")
        fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x160f(%rip), %r12      # 0x62cb
cmpq %r12, %rdi
je 0x4cd5
leaq 0x149f(%rip), %rsi      # 0x6167
movq %rbx, %rdi
callq 0x2110
movq %rax, %r14
jmp 0x4cdf
movq 0x42ec(%rip), %rax      # 0x8fc8
movq (%rax), %r14
movl 0x445f(%rip), %edx      # 0x9144
movl 0x445d(%rip), %ecx      # 0x9148
leaq 0x1477(%rip), %rsi      # 0x6169
movq %r14, %rdi
xorl %eax, %eax
callq 0x2190
cmpl $0x0, 0x4441(%rip)      # 0x9144
jle 0x4d39
leaq 0x4444(%rip), %r13      # 0x9150
leaq 0x145d(%rip), %r15      # 0x6170
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x4414(%rip), %rax      # 0x9144
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4d15
movl $0xa, %edi
movq %r14, %rsi
callq 0x2130
cmpl $0x0, 0x43f7(%rip)      # 0x9144
jle 0x4d83
leaq 0x4bca(%rip), %r13      # 0x9920
leaq 0x1413(%rip), %r15      # 0x6170
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x43ca(%rip), %rax      # 0x9144
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4d5f
movl $0xa, %edi
movq %r14, %rsi
callq 0x2130
cmpl $0x0, 0x43b1(%rip)      # 0x9148
jle 0x4dcd
leaq 0x5350(%rip), %r13      # 0xa0f0
leaq 0x13c9(%rip), %r15      # 0x6170
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x4384(%rip), %rax      # 0x9148
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4da9
cmpq %r12, %rbx
je 0x4de8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: calcFOBIN(tSolucaoBIN&)
void calcFOBIN(SolucaoBIN &s)
{
    memset(&s.vetPesMoc, 0, sizeof(s.vetPesMoc));
    memset(&s.vetQtdMocObj, 0, sizeof(s.vetQtdMocObj));
    s.funObj = 0;
    for(int i = 0; i < numMoc; i++)
        for(int j = 0; j < numObj; j++)
        {
            s.funObj += s.matSol[i][j] * vetValObj[j];
            s.vetPesMoc[i] += s.matSol[i][j] * vetPesObj[j];
            s.vetQtdMocObj[j] += s.matSol[i][j];
        }
    for(int i = 0; i < numMoc; i++)
        s.funObj -= PESO * MAX(0, s.vetPesMoc[i] - vetCapMoc[i]);
    for(int j = 0; j < numObj; j++)
        s.funObj -= PESO2 * MAX(0, s.vetQtdMocObj[j] - 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x18f38(%rdi)
xorl %ebp, %ebp
movl $0x898, %r14d           # imm = 0x898
movl $0x898, %edx            # imm = 0x898
xorl %esi, %esi
callq 0x2080
movslq 0x3cd5(%rip), %rax      # 0x9148
testq %rax, %rax
jle 0x5522
movl 0x3cc2(%rip), %ecx      # 0x9144
movq %rcx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
leaq 0x3cbe(%rip), %rdi      # 0x9150
leaq 0x4487(%rip), %r8       # 0x9920
testl %ecx, %ecx
jle 0x54d4
leaq (%rbx,%r14), %r9
xorl %r10d, %r10d
movl (%r10,%rdi), %r11d
imull (%r9,%r10), %r11d
addl %r11d, 0x18f38(%rbx)
movl (%r9,%r10), %r11d
movl (%r10,%r8), %ebp
imull %r11d, %ebp
addl %ebp, 0x7d0(%rbx,%rsi,4)
addl %r11d, (%rbx,%r10)
addq $0x4, %r10
cmpq %r10, %rdx
jne 0x54a4
incq %rsi
addq $0x7d0, %r14            # imm = 0x7D0
cmpq %rax, %rsi
jne 0x5499
movl 0x18f38(%rbx), %ebp
testl %eax, %eax
jle 0x5522
shlq $0x2, %rax
xorl %ecx, %ecx
leaq 0x4bf6(%rip), %rdx      # 0xa0f0
xorl %esi, %esi
movl 0x7d0(%rbx,%rsi), %edi
subl (%rsi,%rdx), %edi
imull $-0x64, %edi, %r8d
testl %edi, %edi
cmovsl %ecx, %r8d
addl %r8d, %ebp
movl %ebp, 0x18f38(%rbx)
addq $0x4, %rsi
cmpq %rsi, %rax
jne 0x54fc
movslq 0x3c1b(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x5550
xorl %ecx, %ecx
xorl %edx, %edx
movl (%rbx,%rdx,4), %esi
imull $-0x32, %esi, %edi
addl $0x32, %edi
testl %esi, %esi
cmovlel %ecx, %edi
addl %edi, %ebp
movl %ebp, 0x18f38(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x5532
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grmauri[P]pmm/pmm.cpp
// Function: escreverSolucaoBIN(tSolucaoBIN&, bool)
void escreverSolucaoBIN(SolucaoBIN &s, const bool flag)
{
    printf("\nFO: %d\n", s.funObj);
    if(flag)
    {
        printf("VETOR QTD MOCHILAS DE CADA OBJETO: ");
        for(int j = 0; j < numObj; j++)
            printf("%d  ", s.vetQtdMocObj[j]);
        printf("\nVETOR PESO MOCHILAS: ");
        for(int i = 0; i < numMoc; i++)
            printf("%d  ", s.vetPesMoc[i]);\
        printf("\nMATRIZ DE SOLUCAO:\n");
        for(int i = 0; i < numMoc; i++)
        {
            for(int j = 0; j < numObj; j++)
                printf("%d  ", s.matSol[i][j]);
            printf("\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18f38(%rdi), %esi
leaq 0xba8(%rip), %rdi       # 0x6117
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x566d
leaq 0xf91(%rip), %rdi       # 0x6516
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x3bb1(%rip)      # 0x9144
jle 0x55bc
leaq 0xba7(%rip), %r14       # 0x6143
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x3b8d(%rip), %rax      # 0x9144
cmpq %rax, %r15
jl 0x559f
leaq 0xb85(%rip), %rdi       # 0x6148
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x3b77(%rip)      # 0x9148
jle 0x55fe
leaq 0xb69(%rip), %r14       # 0x6143
xorl %r15d, %r15d
movl 0x7d0(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x3b4f(%rip), %rax      # 0x9148
cmpq %rax, %r15
jl 0x55dd
leaq 0x102c(%rip), %rdi      # 0x6631
callq 0x21c0
cmpl $0x0, 0x3b37(%rip)      # 0x9148
jle 0x566d
addq $0x898, %rbx            # imm = 0x898
leaq 0xb22(%rip), %r14       # 0x6143
xorl %r15d, %r15d
cmpl $0x0, 0x3b19(%rip)      # 0x9144
jle 0x564d
xorl %r12d, %r12d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
movslq 0x3afc(%rip), %rax      # 0x9144
cmpq %rax, %r12
jl 0x5630
movl $0xa, %edi
callq 0x2170
incq %r15
movslq 0x3ae7(%rip), %rax      # 0x9148
addq $0x7d0, %rbx            # imm = 0x7D0
cmpq %rax, %r15
jl 0x5624
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/include/filereader.h
// Function: FileReader::getLine[abi:cxx11]()
std::string getLine() {
		std::string line;

		while( getline(file_, line) ){
			if (options_ & OPTION_TRIM)
				trim__(line);

			if ((options_ & OPTION_SKIP_EMPRY) && line.empty() )
				continue;

			return line;
		}

		// return empty line...
		return line;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3857
movb 0x208(%r14), %al
testb $0x1, %al
je 0x384c
movq %rbx, %rdi
callq 0x387e
movb 0x208(%r14), %al
testb $0x2, %al
je 0x3857
cmpq $0x0, 0x8(%rbx)
je 0x3802
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3876
movq (%r15), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/sqlite3-ep-test.cc
// Function: main
int main(int argc, char **args) {
    const char *env_path = getenv("SQLITE_TEST_DB");
    Sqlite3 sq(env_path ? env_path : "/tmp/test.db",
               getenv("KVSTORE_AUDITABLE"));
    EventuallyPersistentStore thing(&sq);

    TestSuite suite(&thing);
    return suite.run() ? 0 : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x5905(%rip), %rdi      # 0x9004
callq 0x3320
testq %rax, %rax
leaq 0x5905(%rip), %rbx      # 0x9013
cmovneq %rax, %rbx
leaq 0x5907(%rip), %rdi      # 0x9020
callq 0x3320
movq %rax, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3abe
leaq 0xa2e0(%rip), %rax      # 0xda18
addq $0x10, %rax
testq %r14, %r14
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
setne 0x19(%r15)
leaq 0x60(%rsp), %rdi
movl $0x8000, %edx           # imm = 0x8000
movq %r15, %rsi
callq 0x689c
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x603c
leaq 0x8(%rsp), %rdi
callq 0x6242
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x8(%rsp), %rdi
callq 0x61be
leaq 0x60(%rsp), %rdi
callq 0x6a8c
leaq 0x28(%rsp), %rdi
callq 0x41aa
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61be
jmp 0x37c6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6a8c
jmp 0x37d5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41aa
movq %rbx, %rdi
callq 0x3440
nop