LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq 0x43a0(%rip), %rcx      # 0x8134
leal -0x1(%rcx), %esi
cltd
idivl %esi
movslq %r15d, %rax
movslq %ebp, %rsi
movslq %r14d, %r11
movslq %ebx, %rbx
movslq %edx, %rdx
imulq $0x89c, %rax, %rax      # imm = 0x89C
leaq 0x5bc9(%rip), %r14      # 0x9980
leaq 0xc8(%r14), %r8
leaq (%rax,%r8), %r9
imulq $0x89c, %rsi, %rdi      # imm = 0x89C
leaq (%rdi,%r8), %r10
imulq $0x89c, %r11, %rsi      # imm = 0x89C
leaq (%rsi,%r8), %r11
imulq $0x89c, %rbx, %rbx      # imm = 0x89C
addq %rbx, %r8
xorl %r15d, %r15d
cmpq %rdx, %r15
jg 0x3dff
movl (%r9,%r15,4), %ebp
movl %ebp, (%r10,%r15,4)
movl (%r11,%r15,4), %ebp
movl %ebp, (%r8,%r15,4)
incq %r15
jmp 0x3de5
leaq 0xcc(%r14), %r8
addq %r8, %rsi
leaq (%rdi,%r8), %r9
addq %r8, %rax
addq %rbx, %r8
leaq 0x1(%rdx), %r10
cmpq %rcx, %r10
jge 0x3e31
movl (%rsi,%rdx,4), %r11d
movl %r11d, (%r9,%rdx,4)
movl (%rax,%rdx,4), %r11d
movl %r11d, (%r8,%rdx,4)
movq %r10, %rdx
jmp 0x3e13
addq %r14, %rdi
callq 0x38ec
addq %r14, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42d3(%rip)            # 0x8134
movslq %edx, %r14
callq 0x2060
cltd
idivl 0x42c4(%rip)            # 0x8134
movslq %edx, %rax
movl 0xc8(%rbx,%rax,4), %ecx
movl 0xc8(%rbx,%r14,4), %edx
cmpl %edx, %ecx
je 0x3e64
movl %ecx, 0xc8(%rbx,%r14,4)
movl %edx, 0xc8(%rbx,%rax,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: 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, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
cmovlel %r14d, %ebp
movl 0x898(%rdi), %esi
pushq $0x1
popq %rax
movl %eax, %r15d
movl %esi, %edx
cmpl %ebp, %r14d
jne 0x3edd
xorl %r14d, %r14d
testl %r15d, %r15d
movl %eax, %r15d
je 0x3ecb
jmp 0x3f5a
movl %edx, 0x4(%rsp)
movl %esi, (%rsp)
callq 0x2060
cltd
idivl 0x4244(%rip)            # 0x8134
movslq %edx, %r12
callq 0x2060
movl 0x423a(%rip), %ecx      # 0x8138
incl %ecx
cltd
idivl %ecx
decl %edx
movl 0xc8(%rbx,%r12,4), %r13d
cmpl %r13d, %edx
je 0x3ef3
movl %edx, 0xc8(%rbx,%r12,4)
movq %rbx, %rdi
callq 0x38ec
movl 0x898(%rbx), %eax
xorl %ecx, %ecx
movl %eax, %edx
movl 0x4(%rsp), %esi
cmpl %esi, %eax
jg 0x3f4a
movl %r13d, 0xc8(%rbx,%r12,4)
movl (%rsp), %eax
movl %eax, 0x898(%rbx)
movl %r15d, %ecx
movl %esi, %edx
incl %r14d
movl %eax, %esi
movl %ecx, %r15d
pushq $0x1
popq %rax
jmp 0x3ecb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: 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), %r13d
movl 0x41a6(%rip), %ecx      # 0x8134
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movq %rcx, 0x10(%rsp)
movl 0x4198(%rip), %ebp      # 0x8138
movl %r13d, (%rsp)
xorl %r12d, %r12d
movl $0x0, 0x4(%rsp)
cmpq 0x10(%rsp), %r12
je 0x4016
movl 0xc8(%rbx,%r12,4), %r14d
pushq $-0x1
popq %r15
cmpl %ebp, %r15d
jge 0x4000
cmpl %r15d, %r14d
je 0x3ffb
movl %r15d, 0xc8(%rbx,%r12,4)
movq %rbx, %rdi
callq 0x38ec
movl 0x898(%rbx), %eax
cmpl %r13d, %eax
jle 0x3ffb
movl %r12d, 0xc(%rsp)
movl %r15d, 0x8(%rsp)
pushq $0x1
popq %rcx
movl %ecx, 0x4(%rsp)
movl %eax, %r13d
incl %r15d
jmp 0x3fc2
movl %r14d, 0xc8(%rbx,%r12,4)
movl (%rsp), %eax
movl %eax, 0x898(%rbx)
incq %r12
jmp 0x3faf
cmpl $0x0, 0x4(%rsp)
je 0x4039
movslq 0xc(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0xc8(%rbx,%rax,4)
movl %r13d, 0x898(%rbx)
jmp 0x3fa0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38ec
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: 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
xorl %r14d, %r14d
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2090
leaq 0xc8(%rbx), %rdi
movl $0x7d0, %edx            # imm = 0x7D0
movl $0xff, %esi
callq 0x2090
movl 0x40b7(%rip), %eax      # 0x8138
testl %eax, %eax
cmovlel %r14d, %eax
movl 0x40a7(%rip), %ecx      # 0x8134
testl %ecx, %ecx
cmovlel %r14d, %ecx
leaq 0x5046(%rip), %rdx      # 0x90e0
leaq 0x510f(%rip), %rsi      # 0x91b0
leaq 0x4868(%rip), %rdi      # 0x8910
cmpq %rcx, %r14
je 0x40e6
movq %rdx, %r9
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x40e1
movslq (%rsi,%r14,4), %r10
movl (%rdi,%r10,4), %r11d
movl (%rbx,%r8,4), %ebp
addl %r11d, %ebp
cmpl (%r9), %ebp
jle 0x40d5
incq %r8
addq $0x4, %r9
jmp 0x40b3
movl %r8d, 0xc8(%rbx,%r10,4)
addl %r11d, (%rbx,%r8,4)
incq %r14
jmp 0x40a8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xfe3(%rip), %rdi       # 0x50e7
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x4181
leaq 0xfda(%rip), %rdi       # 0x50f0
xorl %eax, %eax
callq 0x2050
leaq 0xfef(%rip), %r14       # 0x5113
xorl %r15d, %r15d
movslq 0x4006(%rip), %rax      # 0x8134
cmpq %rax, %r15
jge 0x414a
movl 0xc8(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
jmp 0x4127
leaq 0xfc7(%rip), %rdi       # 0x5118
xorl %eax, %eax
callq 0x2050
leaq 0xfb4(%rip), %r14       # 0x5113
xorl %r15d, %r15d
movslq 0x3fcf(%rip), %rax      # 0x8138
cmpq %rax, %r15
jge 0x4181
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
jmp 0x4162
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: 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 0x10fa(%rip), %r12      # 0x529b
cmpq %r12, %rdi
je 0x41ba
leaq 0xf8a(%rip), %rsi       # 0x5137
movq %rbx, %rdi
callq 0x2110
movq %rax, %r14
jmp 0x41c4
movq 0x3df7(%rip), %rax      # 0x7fb8
movq (%rax), %r14
movl 0x3f6a(%rip), %edx      # 0x8134
movl 0x3f68(%rip), %ecx      # 0x8138
leaq 0xf62(%rip), %rsi       # 0x5139
movq %r14, %rdi
xorl %eax, %eax
callq 0x2180
leaq 0x3f58(%rip), %r13      # 0x8140
leaq 0xf51(%rip), %r15       # 0x5140
xorl %ebp, %ebp
movslq 0x3f3c(%rip), %rax      # 0x8134
cmpq %rax, %rbp
jge 0x4217
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
incq %rbp
addq $0x4, %r13
jmp 0x41f1
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x2130
leaq 0x46e7(%rip), %r13      # 0x8910
leaq 0xf10(%rip), %r15       # 0x5140
xorl %ebp, %ebp
movslq 0x3efb(%rip), %rax      # 0x8134
cmpq %rax, %rbp
jge 0x4258
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
incq %rbp
addq $0x4, %r13
jmp 0x4232
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x2130
leaq 0x4e76(%rip), %r13      # 0x90e0
leaq 0xecf(%rip), %r15       # 0x5140
xorl %ebp, %ebp
movslq 0x3ebe(%rip), %rax      # 0x8138
cmpq %rax, %rbp
jge 0x4299
movl (%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
incq %rbp
addq $0x4, %r13
jmp 0x4273
cmpq %r12, %rbx
je 0x42b4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: testar_buscaLocal()
void testar_buscaLocal()
{
    Solucao sol;
    clock_t h;
    double tempo;

    lerDados("pmm3.txt");
    ordenarObjetos();

    printf("\n\n>>> TESTE - BUSCA LOCAL - PMM3\n\n");

    heuConAle(sol);
    calcFO(sol);
    printf("Solucao inicial:");
    escreverSolucao(sol, 0);

    Solucao sol2;
    memcpy(&sol2, &sol, sizeof(sol));

    Solucao sol3;
    memcpy(&sol3, &sol, sizeof(sol));

    h = clock();
    heuBLPM(sol);
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol, 0);
    printf("BL PM...: %.5f seg.\n",tempo);

    h = clock();
    heuBLMM(sol2);
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol2, 0);
    printf("BL MM...: %.5f seg.\n",tempo);

    h = clock();
    heuBLRA(sol3, (numObj * (numMoc + 1)));
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol3, 0);
    printf("BL RA...: %.5f seg.\n",tempo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a08, %rsp           # imm = 0x1A08
leaq 0xe6c(%rip), %rsi       # 0x5144
leaq 0x10(%rsp), %rbx
leaq 0x34(%rsp), %rdx
movq %rbx, %rdi
callq 0x4bf6
movq %rbx, %rdi
callq 0x2a5b
leaq 0x10(%rsp), %rdi
callq 0x2080
callq 0x2b4a
leaq 0x12d7(%rip), %rdi      # 0x55df
callq 0x21b0
leaq 0x116c(%rsp), %r15
movq %r15, %rdi
callq 0x38af
movq %r15, %rdi
callq 0x38ec
leaq 0xe21(%rip), %rdi       # 0x514d
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0x34(%rsp), %r14
movl $0x89c, %edx            # imm = 0x89C
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
leaq 0x8d0(%rsp), %rbx
movl $0x89c, %edx            # imm = 0x89C
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
callq 0x20b0
movq %rax, %r12
movq %r15, %rdi
callq 0x3bba
callq 0x20b0
subq %r12, %rax
cvtsi2sd %rax, %xmm0
divsd 0xca9(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xdb8(%rip), %rdi       # 0x515e
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
callq 0x20b0
movq %rax, %r15
movq %r14, %rdi
callq 0x3f70
callq 0x20b0
subq %r15, %rax
cvtsi2sd %rax, %xmm0
divsd 0xc60(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xd84(%rip), %rdi       # 0x5173
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
callq 0x20b0
movq %rax, %r14
movl 0x3d2e(%rip), %esi      # 0x8138
incl %esi
imull 0x3d21(%rip), %esi      # 0x8134
movq %rbx, %rdi
callq 0x3ea4
callq 0x20b0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0xc08(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xd41(%rip), %rdi       # 0x5188
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
addq $0x1a08, %rsp           # imm = 0x1A08
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/grmauri[P]pmm/pmm.cpp
// Function: testar_heuConstrutivas()
void testar_heuConstrutivas()
{
    Solucao sol;
    clock_t h;
    double tempo;
    const int repeticoes = 10000;

    lerDados("pmm3.txt");
    ordenarObjetos();

    printf("\n\n>>> TESTE - HEURISTICAS CONSTRUTIVAS - PMM3 - %d REPETICOES\n", repeticoes);

    //---
    h = clock();
    for(int r = 0; r < repeticoes; r++)
        heuConAle(sol);
    calcFO(sol);
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol, 0);
    printf("Construtiva Aleatoria...: %.5f seg.\n",tempo);

    //---
    h = clock();
    for(int r = 0; r < repeticoes; r++)
        heuConGul(sol);
    calcFO(sol);
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol, 0);
    printf("Construtiva Gulosa...: %.5f seg.\n",tempo);

    //---
    h = clock();
    for(int r = 0; r < repeticoes; r++)
        heuConAleGul(sol, 10); // 10% de aleatoriedade
    calcFO(sol);
    h = clock() - h;
    tempo = (double)h/CLOCKS_PER_SEC;
    escreverSolucao(sol, 0);
    printf("Construtiva Aleatoria Gulosa...: %.5f seg.\n",tempo);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
leaq 0xcb8(%rip), %rsi       # 0x5144
leaq 0x18(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x4bf6
movq %rbx, %rdi
callq 0x2a5b
leaq 0x18(%rsp), %rdi
callq 0x2080
callq 0x2b4a
leaq 0xce1(%rip), %rdi       # 0x519d
movl $0x2710, %ebp           # imm = 0x2710
movl $0x2710, %esi           # imm = 0x2710
xorl %eax, %eax
callq 0x2050
callq 0x20b0
movq %rax, %r14
leaq 0x3c(%rsp), %rbx
subl $0x1, %ebp
jb 0x44e9
movq %rbx, %rdi
callq 0x38af
jmp 0x44da
leaq 0x3c(%rsp), %rbx
movq %rbx, %rdi
callq 0x38ec
callq 0x20b0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0xb2d(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xcba(%rip), %rdi       # 0x51dc
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
movl $0x2710, %ebp           # imm = 0x2710
callq 0x20b0
movq %rax, %r14
subl $0x1, %ebp
jb 0x454b
movq %rbx, %rdi
callq 0x404f
jmp 0x453c
leaq 0x3c(%rsp), %rbx
movq %rbx, %rdi
callq 0x38ec
callq 0x20b0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0xacb(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xc7d(%rip), %rdi       # 0x5201
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
movl $0x2710, %r15d          # imm = 0x2710
callq 0x20b0
movq %rax, %r14
pushq $0xa
popq %rbp
subl $0x1, %r15d
jb 0x45b4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3a8a
jmp 0x45a2
leaq 0x3c(%rsp), %rbx
movq %rbx, %rdi
callq 0x38ec
callq 0x20b0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0xa62(%rip), %xmm0      # 0x5038
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40eb
leaq 0xc36(%rip), %rdi       # 0x5223
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x18f38(%rdi)
xorl %r14d, %r14d
movl $0x898, %r15d           # imm = 0x898
movl $0x898, %edx            # imm = 0x898
xorl %esi, %esi
callq 0x2090
movl 0x38c6(%rip), %eax      # 0x8134
testl %eax, %eax
cmovlel %r14d, %eax
movl 0x38be(%rip), %ecx      # 0x8138
testl %ecx, %ecx
cmovlel %r14d, %ecx
leaq (,%rax,4), %rdx
leaq 0x38b1(%rip), %rsi      # 0x8140
leaq 0x407a(%rip), %rdi      # 0x8910
cmpq %rcx, %r14
je 0x48e1
leaq (%rbx,%r15), %r8
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x48d5
movl (%r9,%rsi), %r10d
imull (%r8,%r9), %r10d
addl %r10d, 0x18f38(%rbx)
movl (%r8,%r9), %r10d
movl (%r9,%rdi), %r11d
imull %r10d, %r11d
addl %r11d, 0x7d0(%rbx,%r14,4)
addl %r10d, (%rbx,%r9)
addq $0x4, %r9
jmp 0x48a2
incq %r14
addq $0x7d0, %r15            # imm = 0x7D0
jmp 0x4896
movl 0x18f38(%rbx), %edx
shlq $0x2, %rcx
xorl %esi, %esi
leaq 0x47ec(%rip), %rdi      # 0x90e0
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x4922
movl 0x7d0(%rbx,%r8), %r9d
subl (%r8,%rdi), %r9d
imull $-0x64, %r9d, %r10d
testl %r9d, %r9d
cmovsl %esi, %r10d
addl %r10d, %edx
movl %edx, 0x18f38(%rbx)
addq $0x4, %r8
jmp 0x48f7
movl %eax, %eax
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x494c
movl (%rbx,%rsi,4), %edi
imull $-0x32, %edi, %r8d
addl $0x32, %r8d
testl %edi, %edi
cmovlel %ecx, %r8d
addl %r8d, %edx
movl %edx, 0x18f38(%rbx)
incq %rsi
jmp 0x4928
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x77b(%rip), %rdi       # 0x50e7
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x4a4e
leaq 0xb64(%rip), %rdi       # 0x54e6
xorl %eax, %eax
callq 0x2050
leaq 0x783(%rip), %r14       # 0x5113
xorl %r15d, %r15d
movslq 0x379a(%rip), %rax      # 0x8134
cmpq %rax, %r15
jge 0x49b2
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
jmp 0x4993
leaq 0x75f(%rip), %rdi       # 0x5118
xorl %eax, %eax
callq 0x2050
leaq 0x74c(%rip), %r14       # 0x5113
xorl %r15d, %r15d
movslq 0x3767(%rip), %rax      # 0x8138
cmpq %rax, %r15
jge 0x49ed
movl 0x7d0(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
jmp 0x49ca
leaq 0xc0d(%rip), %rdi       # 0x5601
callq 0x21b0
addq $0x898, %rbx            # imm = 0x898
leaq 0x70c(%rip), %r14       # 0x5113
pushq $0xa
popq %rbp
xorl %r15d, %r15d
movslq 0x3724(%rip), %rax      # 0x8138
cmpq %rax, %r15
jge 0x4a4e
xorl %r12d, %r12d
movslq 0x3711(%rip), %rax      # 0x8134
cmpq %rax, %r12
jge 0x4a3b
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
jmp 0x4a1c
movl %ebp, %edi
callq 0x2170
incq %r15
addq $0x7d0, %rbx            # imm = 0x7D0
jmp 0x4a0d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x21f0
movl $0xf4240, %r15d         # imm = 0xF4240
pushq $0x20
popq %rbp
pushq $0xa
popq %r14
subl $0x1, %r15d
jb 0x2590
movsd 0x2c08(%rip), %xmm0     # 0x5118
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2130
movsd 0x2bf6(%rip), %xmm0     # 0x5120
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2130
movsd 0x2be4(%rip), %xmm0     # 0x5128
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2130
movsd 0x2bd2(%rip), %xmm0     # 0x5130
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2130
movsd 0x2bc0(%rip), %xmm0     # 0x5138
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2130
jmp 0x24fe
leaq 0x8(%rsp), %rdi
callq 0x21a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/stevedonovan[P]outstreams/speedtest.cpp
// Function: main
int main(int argc, char **argv)
{
    U64 start = millisecs();
    testwrite_f("f.dat");
    U64 diff = millisecs() - start;
    U64 stdio_ms = diff;
    outs("stdio ")(diff)("ms")();
    start = millisecs();
    testwrite_s("s.dat");
    diff = millisecs() - start;
    outs("outstreams ")(diff)("ms")();
    start = millisecs();
    testwrite_i("io.dat");
    diff = millisecs() - start;
    outs("iostreams ")(diff)("ms")();
    exec("rm f.dat s.dat io.dat");
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
callq 0x276c
movq %rax, %rbx
leaq 0xa3e(%rip), %rsi       # 0x3016
leaq 0x48(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x27ae
movq %r14, %rdi
callq 0x2467
movq %r14, %rdi
callq 0x2080
callq 0x276c
movq %rax, %r14
subq %rbx, %r14
leaq 0x2b54(%rip), %rdi      # 0x5160
leaq 0xa09(%rip), %rsi       # 0x301c
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x27fc
leaq 0x9f5(%rip), %rsi       # 0x3023
movq %rax, %rdi
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
callq 0x2c8a
callq 0x276c
movq %rax, %rbx
leaq 0x9d7(%rip), %rsi       # 0x3026
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27ae
leaq 0x28(%rsp), %rdi
callq 0x23ac
leaq 0x28(%rsp), %rdi
callq 0x2080
callq 0x276c
movq %rax, %r14
subq %rbx, %r14
leaq 0x2adc(%rip), %rdi      # 0x5160
leaq 0x9a1(%rip), %rsi       # 0x302c
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x27fc
leaq 0x97d(%rip), %rsi       # 0x3023
movq %rax, %rdi
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
callq 0x2c8a
callq 0x276c
movq %rax, %rbx
leaq 0x98b(%rip), %rsi       # 0x3052
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27ae
leaq 0x8(%rsp), %rdi
callq 0x24d1
leaq 0x8(%rsp), %rdi
callq 0x2080
callq 0x276c
movq %rax, %r14
subq %rbx, %r14
leaq 0x2a64(%rip), %rdi      # 0x5160
leaq 0x935(%rip), %rsi       # 0x3038
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x27fc
leaq 0x905(%rip), %rsi       # 0x3023
movq %rax, %rdi
xorl %edx, %edx
callq 0x27ea
movq %rax, %rdi
callq 0x2c8a
leaq 0x90c(%rip), %rdi       # 0x3043
callq 0x20c0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x275a
jmp 0x2761
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2080
jmp 0x2764
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: void listLoad<hm3::VectorList, FileReader>(hm3::VectorList&, FileReader&, bool)
static void listLoad(LIST &list, READER &reader, bool const tombstones = true){
	unsigned int i = 0;

	while( reader ){
		std::string line = reader.getLine();

		const StringRef key = line;
		const StringRef val = tombstones ? nullptr : key;

		if (! key.empty())
			list.put( Pair{ key, val } );

		++i;

		if (i % PROCESS_STEP == 0){
			printf("Processed %10u records, %10zu bytes...\n", i, list.getBytes() );
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
leaq 0x28(%rsp), %r15
movq %rsp, %r13
movl %ebp, %eax
xorl %edx, %edx
movl $0x2710, %ecx           # imm = 0x2710
divl %ecx
movl %eax, %r12d
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
jne 0x3110
movq %r15, %rdi
movq %rbx, %rsi
callq 0x34e6
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
andq $0x0, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x50ba(%rip), %rax      # 0x8160
movq %rax, 0x10(%rsp)
testq %rcx, %rcx
je 0x30da
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6114
movq %r14, %rdi
movq %r13, %rsi
callq 0x510e
movq %r13, %rdi
callq 0x60f4
imull $0x2710, %r12d, %eax    # imm = 0x2710
pushq $0x1
popq %rcx
subl %eax, %ecx
addl %ebp, %ecx
cmpl $0x1, %ecx
jne 0x3101
movq 0x20(%r14), %rdx
leaq 0x503c(%rip), %rdi      # 0x8134
movl %ebp, %esi
xorl %eax, %eax
callq 0x2030
movq %r15, %rdi
callq 0x20e0
incl %ebp
jmp 0x305a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x60f4
jmp 0x312f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x353e
movb 0x208(%r14), %al
testb $0x1, %al
je 0x3533
movq %rbx, %rdi
callq 0x355c
movb 0x208(%r14), %al
testb $0x2, %al
je 0x353e
cmpq $0x0, 0x8(%rbx)
je 0x3500
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/diskfile/diskfilebuilder_impl.h
// Function: bool hm3::diskfile::DiskFileBuilder::createFromIterator<hm3::Pair const*>(StringRef const&, hm3::Pair const* const&, hm3::Pair const* const&, bool) const
bool DiskFileBuilder::createFromIterator(const StringRef &filename, const ITERATOR &begin, const ITERATOR &end,
			bool keepTombstones) const{

	std::ofstream fileMeta(filenameMeta(filename),	std::ios::out | std::ios::binary);
	std::ofstream fileIndx(filenameIndx(filename),	std::ios::out | std::ios::binary);
	std::ofstream fileData(filenameData(filename),	std::ios::out | std::ios::binary);

	return _writeIteratorToFile(begin, end, fileMeta, fileIndx, fileData, keepTombstones);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x628, %rsp            # imm = 0x628
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x228(%rsp), %r13
movq %r13, %rdi
callq 0x3424
leaq 0x428(%rsp), %rdi
pushq $0x14
popq %rdx
movq %r13, %rsi
callq 0x23d0
leaq 0x228(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x3d42
leaq 0x228(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x14
popq %rdx
callq 0x23d0
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3d77
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x14
popq %rdx
callq 0x23d0
leaq 0x8(%rsp), %rdi
callq 0x20e0
movzbl %bpl, %eax
movl %eax, (%rsp)
leaq 0x428(%rsp), %rcx
leaq 0x228(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3dac
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x22e0
leaq 0x228(%rsp), %rdi
callq 0x22e0
leaq 0x428(%rsp), %rdi
callq 0x22e0
movl %ebx, %eax
addq $0x628, %rsp            # imm = 0x628
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22e0
jmp 0x3cfa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x3cfa
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x22e0
jmp 0x3d1b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x3d1b
movq %rax, %rbx
leaq 0x428(%rsp), %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x2380
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x20e0
jmp 0x3d28
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/diskfile/diskfilebuilder_impl.h
// Function: bool hm3::diskfile::DiskFileBuilder::_writeIteratorToFile<hm3::Pair const*>(hm3::Pair const* const&, hm3::Pair const* const&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, bool) const
bool DiskFileBuilder::_writeIteratorToFile(const ITERATOR &begin, const ITERATOR &end,
			std::ofstream &file_meta,
			std::ofstream &file_indx,
			std::ofstream &file_data,
			bool const keepTombstones) const{
	uint64_t be;

	size_t current = 0;

	size_t datacount = 0;
	size_t tombstones = 0;
	uint64_t createdMin = 0;
	uint64_t createdMax = 0;

	bool first_created = true;

	for(ITERATOR it = begin; it != end; ++it){
		const auto &pair = *it;

		if (! pair )
			continue;

		if (pair.isTombstone()){
			if (keepTombstones == false)
					continue;

			++tombstones;
		}

		if (first_created){
			uint64_t const created = pair.getCreated();

			createdMin = created;
			createdMax = created;

			first_created = false;
		}else{
			uint64_t const created = pair.getCreated();

			if (created < createdMin)
				createdMin = created;

			if (created > createdMax)
				createdMax = created;
		}

		// write the index
		be = htobe64(current);
		file_indx.write( (const char *) & be, sizeof(uint64_t));

		// write the data
		pair.fwrite(file_data);

		current += pair.getBytes();
		++datacount;

	//	pair.print();
	}

	// now we miraculasly have the datacount.

	// write table header
	DiskFileHeader head{datacount, true, tombstones, createdMin, createdMax};
	return head.writeToFile(file_meta);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r14
movq (%rsi), %r13
movb $0x1, %al
movl %eax, 0x4(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
movq %rdx, 0x20(%rsp)
cmpq (%r14), %r13
je 0x3ea2
cmpq $0x0, (%r13)
je 0x3e99
movq %r13, %rdi
callq 0x6264
testb %al, %al
je 0x3e23
cmpb $0x0, 0xb0(%rsp)
je 0x3e99
incq 0x8(%rsp)
movq %r13, %rdi
callq 0x61da
movq %rax, %rbp
movq %rax, %r14
testb $0x1, 0x4(%rsp)
jne 0x3e4c
cmpq %r15, %rbp
cmovbq %rbp, %r15
cmpq %r12, %rbp
cmovaq %rbp, %r12
movq %r15, %rbp
movq %r12, %r14
movq %rbx, %rax
bswapq %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2280
movq %r13, %rdi
movq 0x30(%rsp), %rsi
callq 0x62c8
movq %r13, %rdi
callq 0x628c
addq %rax, %rbx
incq 0x10(%rsp)
movl $0x0, 0x4(%rsp)
movq %rbp, %r15
movq %r14, %r12
movq 0x20(%rsp), %r14
addq $0x8, %r13
jmp 0x3df4
leaq 0x40(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x76f0
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x78f2
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x4957(%rip), %rdi      # 0x8004
callq 0x32f0
testq %rax, %rax
leaq 0x4957(%rip), %rbx      # 0x8013
cmovneq %rax, %rbx
leaq 0x4959(%rip), %rdi      # 0x8020
callq 0x32f0
xorl %edx, %edx
testq %rax, %rax
setne %dl
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x376a
leaq 0x58(%rsp), %rdi
movl $0x8000, %edx           # imm = 0x8000
movq %r14, %rsi
callq 0x5c58
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
callq 0x53f0
movq %rsp, %rdi
callq 0x552c
xorb $0x1, %al
movzbl %al, %ebx
movq %rsp, %rdi
callq 0x54e0
leaq 0x58(%rsp), %rdi
callq 0x5e16
leaq 0x20(%rsp), %rdi
callq 0x3f68
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54e0
jmp 0x3749
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5e16
jmp 0x3758
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3f68
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
movq 0x9b94(%rip), %r15      # 0xc1e8
movq 0x9b95(%rip), %r12      # 0xc1f0
cmpq %r12, %r15
je 0x2685
movq (%r15), %r13
xorl %ebp, %ebp
movl (%r13), %eax
cmpl (%r14,%rax,4), %ebp
jge 0x267f
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x2160
incl %ebp
jmp 0x2665
addq $0x8, %r15
jmp 0x265b
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_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0x9b2c(%rip), %rax      # 0xc1e8
movq 0x9b2d(%rip), %rcx      # 0xc1f0
cmpq %rcx, %rax
je 0x26d8
movq (%rax), %rdx
movl (%rdx), %edx
andl $0x0, (%r14,%rdx,4)
addq $0x8, %rax
jmp 0x26c3
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x2708
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x9acf(%rip), %rdx      # 0xc1e8
xorl %esi, %esi
movq 0x9ace(%rip), %rdi      # 0xc1f0
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x26f3
movb (%rax,%rsi), %r8b
movq %rdx, %r9
cmpq %rdi, %r9
je 0x2749
movq (%r9), %r10
addq $0x8, %r9
cmpb 0x10(%r10), %r8b
jne 0x2730
movl (%r10), %r8d
incl (%r14,%r8,4)
incl %esi
jmp 0x2722
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2240
pushq $0x7c
popq %rsi
movq %rax, %rdi
callq 0x21a0
xorl %r15d, %r15d
pushq $0x57
popq %rbp
cmpl 0x4(%r14), %r15d
jge 0x28cd
movq %rbx, %rdi
movl %ebp, %esi
callq 0x21a0
incl %r15d
jmp 0x28b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x928d(%rip), %rax      # 0xbb70
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x2936
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x31e0
movq (%r14), %rdx
movq 0x8(%r14), %rsi
cmpq %rsi, %rdx
je 0x2929
cmpq %rbx, (%rdx)
je 0x2923
movq 0x18(%rdx), %rcx
cmpq %rcx, 0x10(%rdx)
je 0x2923
movq -0x8(%rcx), %rcx
cmpl %ecx, %eax
je 0x2929
addq $0x28, %rdx
jmp 0x2907
cmpq %rsi, %rdx
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
jne 0x293d
movq 0x98fb(%rip), %rcx      # 0xc238
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9224(%rip), %rax      # 0xbb70
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rsi,%rax,4)
jle 0x2983
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x31e0
movl %eax, %ebp
movq 0x38(%rbx), %rax
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x2983
movq 0x20(%rax), %rcx
cmpl %ecx, %ebp
jge 0x298a
movq %rax, %rdi
callq 0x2190
jmp 0x296c
movq 0x98ae(%rip), %rcx      # 0xc238
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x9626(%rip), %r14      # 0xbfd0
leaq 0x4723(%rip), %rsi      # 0x70d4
movq %r14, %rdi
callq 0x2160
leaq 0x28(%rbx), %r15
pushq $0x20
popq %rbp
cmpq 0x38(%rbx), %r15
je 0x29f4
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movq %rax, %r12
movq %r15, %rdi
callq 0x20e0
leaq 0x20(%rax), %rsi
movq %r12, %rdi
callq 0x2893
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
jmp 0x29c0
movq 0x95d5(%rip), %r14      # 0xbfd0
pushq $0xa
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
imulq $0x28, %rax, %rax
movq (%rcx,%rax), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2140
leaq 0x46b2(%rip), %rsi      # 0x70e5
movq %rax, %rdi
callq 0x2160
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
imulq $0x28, %rax, %rax
movq (%rcx,%rax), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2aea
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
imulq $0x28, %rax, %rax
movq (%rcx,%rax), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2140
leaq 0x4674(%rip), %rsi      # 0x70ee
movq %rax, %rdi
callq 0x2160
movq %rax, %r14
movq %r15, %rdi
callq 0x31e0
movq %r14, %rdi
movl %eax, %esi
callq 0x2240
movq %rax, %rdi
movl %ebp, %esi
callq 0x21a0
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2d0e
movl 0x18(%rbx), %ecx
incl %ecx
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movl %edx, 0x18(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ttencate[P]pickomino/game.cc
// Function: Game::playToEnd()
void Game::playToEnd() {
  while (!isOver()) {
    playOneTurn();
  }
  cout << '\n';
  cout << "Game over!\n";
  for (Player const &player : m_players) {
    cout << player.name() << '\t' << player.worms() << '\t';
    for (Tile tile : player.tiles()) {
      cout << tile << ' ';
    }
    cout << '\n';
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
cmpq $0x0, 0x48(%r15)
je 0x303a
movq %r15, %rdi
callq 0x2994
jmp 0x3029
movq 0x8f8f(%rip), %rbx      # 0xbfd0
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x21a0
leaq 0x40a4(%rip), %rsi      # 0x70f7
movq %rbx, %rdi
callq 0x2160
movq (%r15), %r14
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r12
pushq $0x20
popq %r13
cmpq 0x8(%rsp), %r14
je 0x30ff
movq (%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
pushq $0x9
popq %r15
movl %r15d, %esi
callq 0x21a0
movq %rax, %rbp
movq %r14, %rdi
callq 0x320c
movq %rbp, %rdi
movl %eax, %esi
callq 0x2240
movq %rax, %rdi
movl %r15d, %esi
callq 0x21a0
movq 0x10(%r14), %rbp
movq 0x18(%r14), %r15
cmpq %r15, %rbp
je 0x30eb
movq (%rbp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2893
movq %rbx, %rdi
movl %r13d, %esi
callq 0x21a0
addq $0x8, %rbp
jmp 0x30c1
movq %rbx, %rdi
pushq $0xa
popq %rsi
callq 0x21a0
addq $0x28, %r14
jmp 0x3070
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ttencate[P]pickomino/game.cc
// Function: Game::winner() const
int Game::winner() const {
  Worms maxWorms = -1;
  int winner = -1;
  for (unsigned i = 0; i < m_players.size(); ++i) {
    if (m_players[i].worms() > maxWorms) {
      maxWorms = m_players[i].worms();
      winner = i;
    } else if (m_players[i].worms() == maxWorms) {
      return -1; // Tie.
    }
  }
  return winner;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
movl %ebp, %r12d
movl %r13d, %ecx
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
pushq $0x28
popq %rsi
idivq %rsi
cmpq %rcx, %rax
jbe 0x3182
imulq $0x28, %rcx, %r14
addq %r14, %rdi
callq 0x320c
movl %eax, %r15d
addq (%rbx), %r14
movq %r14, %rdi
callq 0x320c
movl %r13d, %ecx
cmpl %r12d, %r15d
jg 0x3175
movl %ebp, %ecx
cmpl %r12d, %eax
movl %r12d, %eax
je 0x317f
incl %r13d
movl %eax, %r12d
movl %ecx, %ebp
jmp 0x312f
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ttencate[P]pickomino/human.cc
// Function: Human::chooseWhetherToRoll(Game const&, Dice const&)
bool Human::chooseWhetherToRoll(Game const &, Dice const &) {
  cout << "Roll again? [Y/n] ";
  string answer;
  do {
    getline(cin, answer);
  } while (answer != "" && answer != "y" && answer != "n");
  return answer == "" || answer == "y";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x8856(%rip), %rdi      # 0xbfd0
leaq 0x3aaf(%rip), %rsi      # 0x7230
callq 0x2160
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8842(%rip), %rbx      # 0xbfe0
movq %rsp, %r14
leaq 0x395a(%rip), %r15      # 0x7102
leaq 0x3a94(%rip), %r12      # 0x7243
leaq 0x3a8f(%rip), %r13      # 0x7245
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movq %r14, %rdi
movq %r15, %rsi
callq 0x3955
testb %al, %al
je 0x37ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x3955
testb %al, %al
je 0x37ee
movq %r14, %rdi
movq %r13, %rsi
callq 0x3955
testb %al, %al
jne 0x37b6
leaq 0x390d(%rip), %rsi      # 0x7102
movq %rsp, %rdi
callq 0x395f
movb $0x1, %bl
testb %al, %al
jne 0x3814
leaq 0x3a39(%rip), %rsi      # 0x7243
movq %rsp, %rdi
callq 0x395f
movl %eax, %ebx
movq %rsp, %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/ttencate[P]pickomino/human.cc
// Function: Human::chooseSideToTake(Game const&, Dice const&, Dice const&)
DieSide const *Human::chooseSideToTake(Game const &, Dice const &taken, Dice const &roll) {
  cout << "Which side to take? [";
  for (DieSide const *side : DieSide::ALL) {
    if (roll.contains(side) && !taken.contains(side)) {
      cout << side->toString();
    }
  }
  cout << "] ";
  string answer;
  DieSide const *side;
  do {
    getline(cin, answer);
    side = DieSide::fromString(answer);
  } while (!side || !roll.contains(side) || taken.contains(side));
  return side;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8775(%rip), %r15      # 0xbfd0
leaq 0x39e5(%rip), %rsi      # 0x7247
movq %r15, %rdi
callq 0x2160
leaq 0x8977(%rip), %rax      # 0xc1e8
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x38a2
movq (%r12), %rax
movl (%rax), %ecx
cmpl $0x0, (%rbx,%rcx,4)
jle 0x389c
cmpl $0x0, (%r14,%rcx,4)
jg 0x389c
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x2160
addq $0x8, %r12
jmp 0x3878
movq 0x8727(%rip), %rdi      # 0xbfd0
leaq 0x3990(%rip), %rsi      # 0x7240
callq 0x2160
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8713(%rip), %r15      # 0xbfe0
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2040
movq %r13, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r13, %rdi
callq 0x396c
movq %rax, %rbp
movq %r13, %rdi
callq 0x20a0
testq %rbp, %rbp
je 0x38d7
movl (%rbp), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x38d7
cmpl $0x0, (%r14,%rax,4)
jg 0x38d7
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbp, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x3943
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2250