LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a9a(%rip), %rdi      # 0x6572
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 0x3ba3
movq %rax, %r12
leaq 0xc(%rsp), %r13
movq %r13, %rdi
movl %ebp, %esi
callq 0x440f
movq %r13, %rdi
callq 0x4264
movq %r13, %rdi
callq 0x4533
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x3b78
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 0x24da(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x2562(%rip), %rdi      # 0x60d3
movb $0x1, %al
callq 0x2050
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x24a8(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3b0c
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2611(%rip), %rdi      # 0x65a9
callq 0x21c0
callq 0x20a0
movq %rax, %r12
movq %r15, %rdi
callq 0x4220
movq %r15, %rdi
callq 0x4264
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x206b(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x20f3(%rip), %rdi      # 0x60d3
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x40c2
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 0x4024
callq 0x4865
jmp 0x4029
callq 0x4311
movq %r13, %rdi
callq 0x4533
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x4087
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 0x1fcf(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x2057(%rip), %rdi      # 0x60d3
movb $0x1, %al
callq 0x2050
xorl %ebp, %ebp
jmp 0x4089
incl %ebp
cmpl $0x2, %ebp
jl 0x4006
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1f8e(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movl $0x0, %ebp
ja 0x4006
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24ca(%rip), %rdi      # 0x65c4
callq 0x21c0
callq 0x20a0
movq %rax, %r12
movq %r15, %rdi
callq 0x4220
movq %r15, %rdi
callq 0x4264
movq %r15, %rdi
callq 0x4533
callq 0x20a0
subq %r12, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x1f01(%rip), %xmm0     # 0x6038
movsd %xmm0, (%r14)
movl 0x898(%r15), %esi
leaq 0x1f89(%rip), %rdi      # 0x60d3
movb $0x1, %al
callq 0x2050
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x420e
leaq 0xc(%rsp), %r13
leaq 0x1f5e(%rip), %rbp      # 0x60d3
movl $0x89c, %edx            # imm = 0x89C
movq %r13, %rdi
movq %r15, %rsi
callq 0x20c0
movq %r13, %rdi
callq 0x4311
movq %r13, %rdi
callq 0x4533
movl 0x8a4(%rsp), %eax
cmpl 0x898(%r15), %eax
jle 0x41e3
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 0x1e6b(%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 0x1e3d(%rip), %xmm0     # 0x6038
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4175
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2080
movl $0x0, 0x898(%rbx)
movslq 0x4ebf(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x42c9
shlq $0x2, %rax
xorl %ecx, %ecx
leaq 0x4eb9(%rip), %rdx      # 0x9150
leaq 0x5682(%rip), %rsi      # 0x9920
cmpl $-0x1, 0xc8(%rbx,%rcx)
je 0x42c0
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 0x429e
movslq 0x4e78(%rip), %rax      # 0x9148
testq %rax, %rax
jle 0x430f
movl 0x898(%rbx), %ecx
shlq $0x2, %rax
xorl %edx, %edx
leaq 0x5e08(%rip), %rsi      # 0xa0f0
xorl %edi, %edi
movl (%rbx,%rdi), %r8d
subl (%rdi,%rsi), %r8d
imull $-0x64, %r8d, %r9d
testl %r8d, %r8d
cmovsl %edx, %r9d
addl %r9d, %ecx
movl %ecx, 0x898(%rbx)
addq $0x4, %rdi
cmpq %rdi, %rax
jne 0x42ea
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e20(%rip)            # 0x9144
movslq %edx, %r14
callq 0x2060
movl 0x4e16(%rip), %ecx      # 0x9148
incl %ecx
cltd
idivl %ecx
decl %edx
cmpl 0xc8(%rbx,%r14,4), %edx
je 0x4327
movl %edx, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4383
movq (%rdi), %r8
movl %esi, %r9d
xorl %esi, %esi
cmpl %edx, (%r8,%rsi,4)
jne 0x437b
movq 0x8(%rdi), %r10
cmpl %ecx, (%r10,%rsi,4)
je 0x4384
incq %rsi
cmpq %rsi, %r9
jne 0x436b
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43b8
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 0x439f
decl %r8d
movl %r8d, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43f8
cmpl $0x2, %eax
jl 0x43f4
movq (%rdi), %rdx
movq 0x8(%rdi), %r9
movl $0x1, %r10d
movl (%rdx,%r10,4), %eax
movl %eax, -0x4(%rdx,%r10,4)
movl (%r9,%r10,4), %eax
movl %eax, -0x4(%r9,%r10,4)
incq %r10
movslq (%rsi), %rax
cmpq %rax, %r10
jl 0x43d7
decl %eax
movl %eax, (%rsi)
movq (%rdi), %rax
movslq (%rsi), %rdx
movl %ecx, (%rax,%rdx,4)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movl %r8d, (%rax,%rcx,4)
incl (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x7d0, %rsp            # imm = 0x7D0
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5d96(%rip), %rsi      # 0xa1c0
movq %rsp, %rdi
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x20c0
cvtsi2sd %ebp, %xmm0
divsd 0x1bfd(%rip), %xmm0     # 0x6040
cvtsi2sdl 0x4cf9(%rip), %xmm1 # 0x9144
mulsd %xmm0, %xmm1
movsd 0x1bf1(%rip), %xmm0     # 0x6048
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
testl %eax, %eax
jle 0x449c
movl %eax, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
callq 0x2060
movl 0x4ccd(%rip), %ecx      # 0x9144
addl %r15d, %ecx
cltd
idivl %ecx
movslq %edx, %rax
addq %r12, %rax
movl (%rsp,%rax,4), %ecx
movl (%rsp,%r12,4), %edx
movl %edx, (%rsp,%rax,4)
movl %ecx, (%rsp,%r12,4)
incq %r12
decl %r15d
cmpq %r12, %r14
jne 0x446c
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
movslq 0x4c7c(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x4523
movl 0x4c75(%rip), %ecx      # 0x9148
xorl %edx, %edx
leaq 0x5444(%rip), %rsi      # 0x9920
leaq 0x5c0d(%rip), %rdi      # 0xa0f0
testl %ecx, %ecx
jle 0x451b
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 0x450f
incq %r10
addq $0x4, %r11
cmpq %r10, %rcx
jne 0x44f5
jmp 0x451b
movl %r10d, 0xc8(%rbx,%r8,4)
addl %r9d, (%rbx,%r10,4)
incq %rdx
cmpq %rax, %rdx
jne 0x44e3
addq $0x7d0, %rsp            # imm = 0x7D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/grmauri[P]pmm/pmm.cpp
// Function: heuBLPM(tSolucao&)
void heuBLPM(Solucao &s)
{
    int vetObjAux[MAX_OBJ]; // usado para evitar determinismo na ordem de teste dos objetos
    int mocOri, foOri, indice, aux;
    int melFO = s.funObj;
    for(int j = 0; j < numObj; j++)
        vetObjAux[j] = j;
    INICIO : ;
    foOri = s.funObj;
    for(int j = 0; j < numObj; j++)
    {
        indice = j + rand()%(numObj - j);
        mocOri = s.vetIdMocObj[vetObjAux[indice]];
        for(int i = -1; i < numMoc; i++)
        {
            if(i != mocOri)
            {
                s.vetIdMocObj[vetObjAux[indice]] = i;
                calcFO(s);
                if(s.funObj > melFO)
                {
                    melFO = s.funObj;
                    goto INICIO;
                }
                else
                {
                    s.vetIdMocObj[vetObjAux[indice]] = mocOri;
                    s.funObj = foOri;
                }
            }
        }
        aux = vetObjAux[j];
        vetObjAux[j] = vetObjAux[indice];
        vetObjAux[indice] = aux;
    }
    calcFO(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7f8, %rsp            # imm = 0x7F8
movq %rdi, %rbx
movl 0x898(%rdi), %eax
movl %eax, 0x4(%rsp)
movslq 0x4bec(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x456b
xorl %ecx, %ecx
movl %ecx, 0x20(%rsp,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x455f
cmpl $0x0, 0x4bd2(%rip)      # 0x9144
setg %cl
jle 0x4657
movl 0x898(%rbx), %eax
movl %eax, 0xc(%rsp)
xorl %r14d, %r14d
movb %cl, 0x3(%rsp)
callq 0x2060
movl 0x4bad(%rip), %ecx      # 0x9144
subl %r14d, %ecx
cltd
idivl %ecx
movq %r14, 0x18(%rsp)
addl %r14d, %edx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rsp,%rax,4), %eax
movl 0x4b90(%rip), %r13d     # 0x9148
testl %r13d, %r13d
setns %r14b
movl %eax, 0x8(%rsp)
js 0x4615
movslq %eax, %r15
movl 0xc8(%rbx,%r15,4), %ebp
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %r12d, %ebp
je 0x4609
movl %r12d, 0xc8(%rbx,%r15,4)
movq %rbx, %rdi
callq 0x4264
movl 0x898(%rbx), %eax
cmpl 0x4(%rsp), %eax
jg 0x4619
movl %ebp, 0xc8(%rbx,%r15,4)
movl 0xc(%rsp), %eax
movl %eax, 0x898(%rbx)
incl %r12d
cmpl %r13d, %r12d
setl %r14b
jne 0x45d6
movl 0x4(%rsp), %eax
testb $0x1, %r14b
jne 0x465d
movq 0x18(%rsp), %r14
movl 0x20(%rsp,%r14,4), %ecx
movl 0x8(%rsp), %edx
movl %edx, 0x20(%rsp,%r14,4)
movq 0x10(%rsp), %rdx
movl %ecx, 0x20(%rsp,%rdx,4)
incq %r14
movslq 0x4aff(%rip), %rcx      # 0x9144
movl %eax, 0x4(%rsp)
cmpq %rcx, %r14
setl %cl
jl 0x4588
jmp 0x4661
movl 0x4(%rsp), %eax
jmp 0x4661
movb 0x3(%rsp), %cl
movl %eax, 0x4(%rsp)
testb $0x1, %cl
jne 0x456b
movq %rbx, %rdi
addq $0x7f8, %rsp            # imm = 0x7F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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 0x472e
movq (%rsp), %rax
decl %eax
movl %eax, %eax
imulq $0x89c, %rax, %r13      # imm = 0x89C
leaq 0x62d5(%rip), %rbp      # 0xa990
leaq 0xc(%rsp), %r14
xorl %ebx, %ebx
xorl %eax, %eax
movl 0x898(%rbx,%rbp), %ecx
cmpl 0x1134(%rbx,%rbp), %ecx
jge 0x4718
leaq (%rbx,%rbp), %r15
leaq (%rbx,%rbp), %r12
addq $0x89c, %r12            # imm = 0x89C
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
addq $0x89c, %rbx            # imm = 0x89C
cmpq %rbx, %r13
jne 0x46c4
testl %eax, %eax
je 0x472e
cmpl $0x2, (%rsp)
jge 0x46c0
addq $0x8a8, %rsp            # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
callq 0x2060
movl 0x49e8(%rip), %ecx      # 0x9144
leal -0x1(%rcx), %esi
cltd
idivl %esi
movslq %ebp, %rax
movslq %ebx, %rbx
movslq %r14d, %rdi
movslq %r15d, %rsi
testl %edx, %edx
js 0x47c7
leal 0x1(%rdx), %r8d
imulq $0x89c, %rsi, %r9       # imm = 0x89C
leaq 0x620c(%rip), %r15      # 0xa990
addq $0xc8, %r15
addq %r15, %r9
imulq $0x89c, %rax, %r10      # imm = 0x89C
addq %r15, %r10
imulq $0x89c, %rdi, %r11      # imm = 0x89C
addq %r15, %r11
imulq $0x89c, %rbx, %r14      # imm = 0x89C
addq %r15, %r14
xorl %r15d, %r15d
movl (%r9,%r15,4), %ebp
movl %ebp, (%r10,%r15,4)
movl (%r11,%r15,4), %ebp
movl %ebp, (%r14,%r15,4)
incq %r15
cmpq %r15, %r8
jne 0x47af
leal 0x1(%rdx), %r8d
cmpl %ecx, %r8d
jge 0x4836
movslq %r8d, %r9
imulq $0x89c, %rdi, %rdi      # imm = 0x89C
leaq (%rdi,%r9,4), %rdi
leaq 0x61ab(%rip), %r10      # 0xa990
addq $0xc8, %r10
addq %r10, %rdi
imulq $0x89c, %rax, %r8       # imm = 0x89C
leaq (%r8,%r9,4), %r8
addq %r10, %r8
imulq $0x89c, %rsi, %rsi      # imm = 0x89C
leaq (%rsi,%r9,4), %rsi
addq %r10, %rsi
imulq $0x89c, %rbx, %r11      # imm = 0x89C
leaq (%r11,%r9,4), %r9
addq %r10, %r9
notl %edx
addl %ecx, %edx
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %r10d
movl %r10d, (%r8,%rcx,4)
movl (%rsi,%rcx,4), %r10d
movl %r10d, (%r9,%rcx,4)
incq %rcx
cmpl %ecx, %edx
jne 0x481f
imulq $0x89c, %rax, %rdi      # imm = 0x89C
leaq 0x614c(%rip), %r14      # 0xa990
addq %r14, %rdi
callq 0x4264
imulq $0x89c, %rbx, %rdi      # imm = 0x89C
addq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48cc(%rip)            # 0x9144
movslq %edx, %r14
callq 0x2060
cltd
idivl 0x48bd(%rip)            # 0x9144
movslq %edx, %rax
movl 0xc8(%rbx,%rax,4), %ecx
movl 0xc8(%rbx,%r14,4), %edx
cmpl %edx, %ecx
je 0x487b
movl %ecx, 0xc8(%rbx,%r14,4)
movl %edx, 0xc8(%rbx,%rax,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r14d, %r14d
cmpl $0x0, (%rsp)
jle 0x4961
movl $0x1, %ecx
movl %ecx, 0x4(%rsp)
movl %eax, %r15d
movl 0x898(%rbx), %r13d
callq 0x2060
cltd
idivl 0x4846(%rip)            # 0x9144
movslq %edx, %rbp
callq 0x2060
movl 0x483c(%rip), %ecx      # 0x9148
incl %ecx
cltd
idivl %ecx
decl %edx
movl 0xc8(%rbx,%rbp,4), %r12d
cmpl %r12d, %edx
je 0x4901
movl %edx, 0xc8(%rbx,%rbp,4)
movq %rbx, %rdi
callq 0x4264
movl 0x898(%rbx), %eax
xorl %ecx, %ecx
cmpl %r15d, %eax
jg 0x4952
movl %r12d, 0xc8(%rbx,%rbp,4)
movl %r13d, 0x898(%rbx)
movl 0x4(%rsp), %ecx
movl %r15d, %eax
incl %r14d
cmpl (%rsp), %r14d
jne 0x48e4
testl %ecx, %ecx
sete %r14b
testb %r14b, %r14b
jne 0x48d2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x898(%rdi), %r15d
movl 0x47a6(%rip), %eax      # 0x9144
movq %rax, 0x10(%rsp)
movl 0x479f(%rip), %ebp      # 0x9148
cmpl $0x0, 0x10(%rsp)
jle 0x4a3b
movl 0x898(%rbx), %eax
movl %eax, 0x4(%rsp)
xorl %r14d, %r14d
movl $0x0, (%rsp)
movl 0xc8(%rbx,%r14,4), %r13d
testl %ebp, %ebp
js 0x4a16
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %r12d, %r13d
je 0x4a0e
movl %r12d, 0xc8(%rbx,%r14,4)
movq %rbx, %rdi
callq 0x4264
movl 0x898(%rbx), %eax
cmpl %r15d, %eax
jle 0x4a0e
movl $0x1, (%rsp)
movl %r14d, 0xc(%rsp)
movl %r12d, 0x8(%rsp)
movl %eax, %r15d
incl %r12d
cmpl %r12d, %ebp
jne 0x49da
movl %r13d, 0xc8(%rbx,%r14,4)
movl 0x4(%rsp), %eax
movl %eax, 0x898(%rbx)
incq %r14
cmpq 0x10(%rsp), %r14
jne 0x49c8
cmpl $0x0, (%rsp)
sete %al
jmp 0x4a3d
movb $0x1, %al
testb %al, %al
jne 0x4a5d
movslq 0xc(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0xc8(%rbx,%rax,4)
movl %r15d, 0x898(%rbx)
jmp 0x49a9
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4264
// File: /workspace/github_cpp_makefile_star2_O1/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 0x46a1(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x4b05
movl 0x469a(%rip), %ecx      # 0x9148
xorl %edx, %edx
leaq 0x5709(%rip), %rsi      # 0xa1c0
leaq 0x4e62(%rip), %rdi      # 0x9920
leaq 0x562b(%rip), %r8       # 0xa0f0
testl %ecx, %ecx
jle 0x4afd
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 0x4af1
incq %r11
addq $0x4, %r14
cmpq %r11, %rcx
jne 0x4ad7
jmp 0x4afd
movl %r11d, 0xc8(%rbx,%r9,4)
addl %r10d, (%rbx,%r11,4)
incq %rdx
cmpq %rax, %rdx
jne 0x4ac5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15c4(%rip), %rdi      # 0x60e7
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x4bb2
leaq 0x15b7(%rip), %rdi      # 0x60f0
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x45fd(%rip)      # 0x9144
jle 0x4b74
leaq 0x15c3(%rip), %r14      # 0x6113
xorl %r15d, %r15d
movl 0xc8(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x45d5(%rip), %rax      # 0x9144
cmpq %rax, %r15
jl 0x4b53
leaq 0x159d(%rip), %rdi      # 0x6118
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x45bf(%rip)      # 0x9148
jle 0x4bb2
leaq 0x1581(%rip), %r14      # 0x6113
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x459b(%rip), %rax      # 0x9148
cmpq %rax, %r15
jl 0x4b95
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16c9(%rip), %r12      # 0x629b
cmpq %r12, %rdi
je 0x4beb
leaq 0x1559(%rip), %rsi      # 0x6137
movq %rbx, %rdi
callq 0x2110
movq %rax, %r14
jmp 0x4bf5
movq 0x43d6(%rip), %rax      # 0x8fc8
movq (%rax), %r14
movl 0x4549(%rip), %edx      # 0x9144
movl 0x4547(%rip), %ecx      # 0x9148
leaq 0x1531(%rip), %rsi      # 0x6139
movq %r14, %rdi
xorl %eax, %eax
callq 0x2190
cmpl $0x0, 0x452b(%rip)      # 0x9144
jle 0x4c4f
leaq 0x452e(%rip), %r13      # 0x9150
leaq 0x1517(%rip), %r15      # 0x6140
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x44fe(%rip), %rax      # 0x9144
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4c2b
movl $0xa, %edi
movq %r14, %rsi
callq 0x2130
cmpl $0x0, 0x44e1(%rip)      # 0x9144
jle 0x4c99
leaq 0x4cb4(%rip), %r13      # 0x9920
leaq 0x14cd(%rip), %r15      # 0x6140
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x44b4(%rip), %rax      # 0x9144
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4c75
movl $0xa, %edi
movq %r14, %rsi
callq 0x2130
cmpl $0x0, 0x449b(%rip)      # 0x9148
jle 0x4ce3
leaq 0x543a(%rip), %r13      # 0xa0f0
leaq 0x1483(%rip), %r15      # 0x6140
xorl %ebp, %ebp
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq 0x446e(%rip), %rax      # 0x9148
addq $0x4, %r13
cmpq %rax, %rbp
jl 0x4cbf
cmpq %r12, %rbx
je 0x4cfe
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_O1/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)
movl $0x898, %r14d           # imm = 0x898
movl $0x898, %edx            # imm = 0x898
xorl %esi, %esi
callq 0x2080
movslq 0x3dc5(%rip), %rax      # 0x9148
testq %rax, %rax
jle 0x53ef
movl 0x3db6(%rip), %ecx      # 0x9144
movq %rcx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
leaq 0x3db2(%rip), %rdi      # 0x9150
leaq 0x457b(%rip), %r8       # 0x9920
testl %ecx, %ecx
jle 0x53e0
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 0x53b0
incq %rsi
addq $0x7d0, %r14            # imm = 0x7D0
cmpq %rax, %rsi
jne 0x53a5
testl %eax, %eax
jle 0x5431
movl 0x18f38(%rbx), %ecx
shlq $0x2, %rax
xorl %edx, %edx
leaq 0x4cea(%rip), %rsi      # 0xa0f0
xorl %edi, %edi
movl 0x7d0(%rbx,%rdi), %r8d
subl (%rdi,%rsi), %r8d
imull $-0x64, %r8d, %r9d
testl %r8d, %r8d
cmovsl %edx, %r9d
addl %r9d, %ecx
movl %ecx, 0x18f38(%rbx)
addq $0x4, %rdi
cmpq %rdi, %rax
jne 0x5408
movslq 0x3d0c(%rip), %rax      # 0x9144
testq %rax, %rax
jle 0x5469
movl 0x18f38(%rbx), %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%rbx,%rsi,4), %edi
imull $-0x32, %edi, %r8d
addl $0x32, %r8d
testl %edi, %edi
cmovlel %edx, %r8d
addl %r8d, %ecx
movl %ecx, 0x18f38(%rbx)
incq %rsi
cmpq %rsi, %rax
jne 0x5447
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc5f(%rip), %rdi       # 0x60e7
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x5586
leaq 0x1048(%rip), %rdi      # 0x64e6
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x3c98(%rip)      # 0x9144
jle 0x54d5
leaq 0xc5e(%rip), %r14       # 0x6113
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x3c74(%rip), %rax      # 0x9144
cmpq %rax, %r15
jl 0x54b8
leaq 0xc3c(%rip), %rdi       # 0x6118
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x3c5e(%rip)      # 0x9148
jle 0x5517
leaq 0xc20(%rip), %r14       # 0x6113
xorl %r15d, %r15d
movl 0x7d0(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
movslq 0x3c36(%rip), %rax      # 0x9148
cmpq %rax, %r15
jl 0x54f6
leaq 0x10e3(%rip), %rdi      # 0x6601
callq 0x21c0
cmpl $0x0, 0x3c1e(%rip)      # 0x9148
jle 0x5586
addq $0x898, %rbx            # imm = 0x898
leaq 0xbd9(%rip), %r14       # 0x6113
xorl %r15d, %r15d
cmpl $0x0, 0x3c00(%rip)      # 0x9144
jle 0x5566
xorl %r12d, %r12d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
movslq 0x3be3(%rip), %rax      # 0x9144
cmpq %rax, %r12
jl 0x5549
movl $0xa, %edi
callq 0x2170
incq %r15
movslq 0x3bce(%rip), %rax      # 0x9148
addq $0x7d0, %rbx            # imm = 0x7D0
cmpq %rax, %r15
jl 0x553d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stevedonovan[P]outstreams/speedtest.cpp
// Function: testwrite_i(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void testwrite_i(string file) {
    ofstream out(file);

    for (int i = 0; i < N; i++) {
        out << x1 << ' ' << x2 << ' ' << x3
             << ' ' << x4 << ' ' << x5 << '\n';
    }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x21f0
movl $0xf4240, %ebp          # imm = 0xF4240
leaq 0xf(%rsp), %r14
movsd 0x3bed(%rip), %xmm0     # 0x6118
movq %rbx, %rdi
callq 0x21c0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movsd 0x3bd0(%rip), %xmm0     # 0x6120
movq %rax, %rdi
callq 0x21c0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movsd 0x3bb3(%rip), %xmm0     # 0x6128
movq %rax, %rdi
callq 0x21c0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movsd 0x3b96(%rip), %xmm0     # 0x6130
movq %rax, %rdi
callq 0x21c0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movsd 0x3b79(%rip), %xmm0     # 0x6138
movq %rax, %rdi
callq 0x21c0
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
decl %ebp
jne 0x2523
movq 0x39ed(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x18(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x10(%rsp,%rcx)
callq 0x20c0
leaq 0x108(%rsp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3851
testb $0x1, 0x208(%r14)
je 0x3840
movq %rbx, %rdi
callq 0x3878
testb $0x2, 0x208(%r14)
je 0x3851
cmpq $0x0, 0x8(%rbx)
je 0x37fe
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3870
movq (%r15), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68c8
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6074
leaq 0x8(%rsp), %rdi
callq 0x6276
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x8(%rsp), %rdi
callq 0x61f6
leaq 0x60(%rsp), %rdi
callq 0x6ab8
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 0x61f6
jmp 0x37c6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6ab8
jmp 0x37d5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41aa
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/dice.cc
// Function: operator<<(std::ostream&, Dice const&)
ostream &operator<<(ostream &out, Dice const &dice) {
  for (DieSide const *side : DieSide::ALL) {
    for (int j = 0; j < dice[side]; ++j) {
      out << side->toString();
    }
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8a7f(%rip), %r12      # 0xb1f0
movq 0x8a80(%rip), %rax      # 0xb1f8
movq %rax, (%rsp)
cmpq %rax, %r12
je 0x27e3
movq %rsi, %r14
movq (%r12), %rbp
movl (%rbp), %eax
cmpl $0x0, (%r14,%rax,4)
jle 0x27d9
xorl %r13d, %r13d
movq 0x8(%rbp), %r15
testq %r15, %r15
je 0x27b6
movq %r15, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x27cd
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2220
incl %r13d
movl (%rbp), %eax
cmpl (%r14,%rax,4), %r13d
jl 0x2795
addq $0x8, %r12
cmpq (%rsp), %r12
jne 0x2784
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/dice.cc
// Function: operator>>(std::istream&, Dice&)
istream &operator>>(istream &in, Dice &dice) {
  string input;
  for (DieSide const *side : DieSide::ALL) {
    dice[side] = 0;
  }
  if (in >> input) {
    for (unsigned i = 0; i < input.size(); ++i) {
      char c = input[i];
      for (DieSide const *side : DieSide::ALL) {
        if (c == side->inputChar()) {
          dice[side]++;
          break;
        }
      }
    }
  }
  return in;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x89d0(%rip), %rax      # 0xb1f0
movq 0x89d1(%rip), %rcx      # 0xb1f8
cmpq %rcx, %rax
je 0x283f
movq (%rax), %rdx
movl (%rdx), %edx
movl $0x0, (%r14,%rdx,4)
addq $0x8, %rax
jmp 0x2827
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x28a8
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x28a8
movq (%rsp), %rcx
movq 0x8983(%rip), %rdx      # 0xb1f0
movq 0x8984(%rip), %rsi      # 0xb1f8
xorl %edi, %edi
cmpq %rsi, %rdx
je 0x289d
movb (%rcx,%rdi), %r8b
movq %rdx, %r9
movq (%r9), %r10
cmpb 0x10(%r10), %r8b
je 0x2896
addq $0x8, %r9
cmpq %rsi, %r9
jne 0x2882
jmp 0x289d
movl (%r10), %r8d
incl (%r14,%r8,4)
incq %rdi
movl %edi, %r8d
cmpq %r8, %rax
ja 0x2876
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x28b6
callq 0x2140
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x28d4
callq 0x2140
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/game.cc
// Function: operator<<(std::ostream&, Tile const&)
std::ostream &operator<<(std::ostream &out, Tile const &tile) {
  out << tile.score() << '|';
  for (int i = 0; i < tile.worms(); i++) {
    out << 'W';
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x2230
leaq 0x7(%rsp), %rsi
movb $0x7c, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
cmpl $0x0, 0x4(%r14)
jle 0x2a57
xorl %ebp, %ebp
leaq 0x6(%rsp), %r15
movb $0x57, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
incl %ebp
cmpl 0x4(%r14), %ebp
jl 0x2a3a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/game.cc
// Function: Game::stealableTile(Strategy const*, Dice const&) const
Tile Game::stealableTile(Strategy const *thief, Dice const &dice) const {
  if (!dice.contains(DieSide::WORM)) {
    return Tile::INVALID;
  }
  Score score = dice.sum();
  for (Player const &player : m_players) {
    if (!player.hasStrategy(thief) && player.hasTiles() && player.topTile().score() == score) {
      return player.topTile();
    }
  }
  return Tile::INVALID;
}

// Assembly:
leaq 0x80cb(%rip), %rax      # 0xab38
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x2aeb
leaq 0x8771(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %r8
xorl %ecx, %ecx
cmpq %r8, %rax
je 0x2aa5
movq (%rax), %r9
movl (%r9), %r10d
movl 0x4(%r9), %r9d
imull (%rdx,%r10,4), %r9d
addl %r9d, %ecx
addq $0x8, %rax
jmp 0x2a88
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
cmpq %rdi, %r8
sete %dl
je 0x2ae6
movb $0x1, %r9b
cmpq %rsi, (%r8)
je 0x2ad5
movq 0x18(%r8), %r10
cmpq %r10, 0x10(%r8)
je 0x2ad5
movq -0x8(%r10), %r10
cmpl %r10d, %ecx
setne %r9b
cmoveq %r10, %rax
testb %r9b, %r9b
je 0x2ae6
addq $0x28, %r8
cmpq %rdi, %r8
sete %dl
jne 0x2ab4
testb $0x1, %dl
je 0x2af2
movq 0x874e(%rip), %rax      # 0xb240
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/game.cc
// Function: Game::bestRemainingTile(Dice const&) const
Tile Game::bestRemainingTile(Dice const &dice) const {
  if (!dice.contains(DieSide::WORM)) {
    return Tile::INVALID;
  }
  Score score = dice.sum();
  for (Tile tile : m_tiles) {
    if (score >= tile.score()) {
      return tile;
    }
  }
  return Tile::INVALID;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x803a(%rip), %rax      # 0xab38
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rsi,%rax,4)
jle 0x2b54
movq %rdi, %rbx
leaq 0x86dd(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x2b35
movq (%rax), %rdx
movl (%rdx), %edi
movl 0x4(%rdx), %edx
imull (%rsi,%rdi,4), %edx
addl %edx, %ebp
addq $0x8, %rax
jmp 0x2b1c
movq 0x38(%rbx), %rax
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x2b54
movq 0x20(%rax), %rcx
cmpl %ecx, %ebp
jge 0x2b5b
movq %rax, %rdi
callq 0x2190
jmp 0x2b3d
movq 0x86e5(%rip), %rcx      # 0xb240
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ttencate[P]pickomino/game.cc
// Function: Game::playOneTurn()
void Game::playOneTurn() {
  cout << "Remaining tiles:";
  for (auto i = m_tiles.rbegin(); i != m_tiles.rend(); i++) {
    cout << ' ' << *i;
  }
  cout << '\n';
  cout << '\n';

  cout << currentPlayer().name() << "'s turn\n";
  Dice taken = takeTurn(currentPlayer().strategy());
  cout << currentPlayer().name() << " scored " << taken.sum() << '\n';
  takeOrLoseTile(taken);

  m_currentPlayer = (m_currentPlayer + 1) % m_players.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8452(%rip), %rdi      # 0xafd0
leaq 0x455f(%rip), %rsi      # 0x70e4
movl $0x10, %edx
callq 0x2180
leaq 0x28(%rbx), %r14
cmpq 0x38(%rbx), %r14
je 0x2be2
movq 0x8430(%rip), %r15      # 0xafd0
leaq 0x1f(%rsp), %r12
movb $0x20, 0x1f(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
callq 0x20c0
leaq 0x20(%rax), %rsi
movq %r13, %rdi
callq 0x2a03
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
cmpq 0x38(%rbx), %rax
jne 0x2ba5
movb $0xa, %bpl
leaq 0x1f(%rsp), %r15
movb %bpl, (%r15)
movq 0x83dc(%rip), %r14      # 0xafd0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movb %bpl, (%r15)
leaq 0x1f(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2180
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x2180
leaq 0x44b7(%rip), %rsi      # 0x70f5
movl $0x8, %edx
movq %rax, %rdi
callq 0x2180
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rdx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d32
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
leaq 0x4470(%rip), %rsi      # 0x70fe
movl $0x8, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x854e(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x2cc5
movq (%rax), %rdx
movl (%rdx), %edi
movl 0x4(%rdx), %edx
imull 0x20(%rsp,%rdi,4), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x2cab
movq %r14, %rdi
callq 0x2230
leaq 0x1f(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x302a
movl 0x18(%rbx), %eax
incl %eax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rsi
xorl %edx, %edx
divq %rsi
movl %edx, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq