LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x4e67(%rip), %eax      # 0xa1a4
jge 0x53f5
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl -0x28(%rbp), %eax
cmpl 0x4e43(%rip), %eax      # 0xa1a8
jge 0x53c8
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x53bb
movl -0x28(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x46f0
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
cmpl -0x20(%rbp), %eax
jle 0x53b9
movq -0x8(%rbp), %rax
movl 0x898(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x53bb
jmp 0x53bd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x535c
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x898(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5334
cmpl $0x0, -0x1c(%rbp)
je 0x541c
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x898(%rax)
jmp 0x541e
jmp 0x5423
jmp 0x5319
movq -0x8(%rbp), %rdi
callq 0x46f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
movl $0xff, %esi
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x20d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4d1e(%rip), %eax      # 0xa1a4
jge 0x553c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x4d0c(%rip), %eax      # 0xa1a8
jge 0x552c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0xc(%rbp), %rdx
leaq 0x5d68(%rip), %rcx      # 0xb220
movslq (%rcx,%rdx,4), %rdx
leaq 0x54bd(%rip), %rcx      # 0xa980
addl (%rcx,%rdx,4), %eax
movslq -0x10(%rbp), %rdx
leaq 0x5c7f(%rip), %rcx      # 0xb150
cmpl (%rcx,%rdx,4), %eax
jg 0x551c
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rsi
leaq 0x5d38(%rip), %rcx      # 0xb220
movslq (%rcx,%rsi,4), %rcx
movl %edx, 0xc8(%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
leaq 0x5d22(%rip), %rax      # 0xb220
movslq (%rax,%rcx,4), %rcx
leaq 0x5477(%rip), %rax      # 0xa980
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x552c
jmp 0x551e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5493
jmp 0x552e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x547d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x898(%rax), %esi
leaq 0x1bf9(%rip), %rdi      # 0x716e
movb $0x0, %al
callq 0x2050
testb $0x1, -0x9(%rbp)
je 0x5614
leaq 0x1bea(%rip), %rdi      # 0x7177
movb $0x0, %al
callq 0x2050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x4c00(%rip), %eax      # 0xa1a4
jge 0x55ce
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0xc8(%rax,%rcx,4), %esi
leaq 0x1bde(%rip), %rdi      # 0x719a
movb $0x0, %al
callq 0x2050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x559b
leaq 0x1bca(%rip), %rdi      # 0x719f
movb $0x0, %al
callq 0x2050
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x4bbc(%rip), %eax      # 0xa1a8
jge 0x5612
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x1b9a(%rip), %rdi      # 0x719a
movb $0x0, %al
callq 0x2050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55e3
jmp 0x5614
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1a9a(%rip), %rax      # 0x70cd
cmpq %rax, -0x8(%rbp)
jne 0x5649
movq 0x4978(%rip), %rax      # 0x9fb8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x565d
movq -0x8(%rbp), %rdi
leaq 0x1b6a(%rip), %rsi      # 0x71be
callq 0x21d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl 0x4b3d(%rip), %edx      # 0xa1a4
movl 0x4b3b(%rip), %ecx      # 0xa1a8
leaq 0x1b4c(%rip), %rsi      # 0x71c0
movb $0x0, %al
callq 0x2240
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x4b19(%rip), %eax      # 0xa1a4
jge 0x56b8
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x4b14(%rip), %rax      # 0xa1b0
movl (%rax,%rcx,4), %edx
leaq 0x1b21(%rip), %rsi      # 0x71c7
movb $0x0, %al
callq 0x2240
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5682
movq -0x10(%rbp), %rdi
leaq 0x1a09(%rip), %rsi      # 0x70cc
movb $0x0, %al
callq 0x2240
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x4aca(%rip), %eax      # 0xa1a4
jge 0x5707
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rcx
leaq 0x5295(%rip), %rax      # 0xa980
movl (%rax,%rcx,4), %edx
leaq 0x1ad2(%rip), %rsi      # 0x71c7
movb $0x0, %al
callq 0x2240
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x56d1
movq -0x10(%rbp), %rdi
leaq 0x19ba(%rip), %rsi      # 0x70cc
movb $0x0, %al
callq 0x2240
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x4a7f(%rip), %eax      # 0xa1a8
jge 0x5756
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x5a16(%rip), %rax      # 0xb150
movl (%rax,%rcx,4), %edx
leaq 0x1a83(%rip), %rsi      # 0x71c7
movb $0x0, %al
callq 0x2240
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5720
leaq 0x1970(%rip), %rax      # 0x70cd
cmpq %rax, -0x8(%rbp)
je 0x576c
movq -0x10(%rbp), %rdi
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x18f38(%rax), %esi
leaq 0xef9(%rip), %rdi       # 0x716e
movb $0x0, %al
callq 0x2050
testb $0x1, -0x9(%rbp)
je 0x6397
leaq 0x1303(%rip), %rdi      # 0x7590
movb $0x0, %al
callq 0x2050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x3f00(%rip), %eax      # 0xa1a4
jge 0x62ca
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xee2(%rip), %rdi       # 0x719a
movb $0x0, %al
callq 0x2050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x629b
leaq 0xece(%rip), %rdi       # 0x719f
movb $0x0, %al
callq 0x2050
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x3ec0(%rip), %eax      # 0xa1a8
jge 0x6312
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x7d0(%rax,%rcx,4), %esi
leaq 0xe9a(%rip), %rdi       # 0x719a
movb $0x0, %al
callq 0x2050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62df
leaq 0x129b(%rip), %rdi      # 0x75b4
movb $0x0, %al
callq 0x2050
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x3e78(%rip), %eax      # 0xa1a8
jge 0x6395
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x3e62(%rip), %eax      # 0xa1a4
jge 0x637c
movq -0x8(%rbp), %rax
addq $0x898, %rax            # imm = 0x898
movslq -0x18(%rbp), %rcx
imulq $0x7d0, %rcx, %rcx      # imm = 0x7D0
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xe30(%rip), %rdi       # 0x719a
movb $0x0, %al
callq 0x2050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6339
leaq 0xd49(%rip), %rdi       # 0x70cc
movb $0x0, %al
callq 0x2050
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6327
jmp 0x6397
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/speedtest.cpp
// Function: testwrite_s(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void testwrite_s(string file) {
    Writer w(file.c_str());
    w.sep(' ');

    for (int i = 0; i < N; i++) {
        w(x1)(x2)(x3)(x4)(x5)();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
callq 0x20a0
movq %rax, %rsi
leaq 0x1b49(%rip), %rdx      # 0x4004
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3470
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x3660
jmp 0x24d8
movl $0x0, -0x30(%rbp)
cmpl $0xf4240, -0x30(%rbp)   # imm = 0xF4240
jge 0x25a5
movsd 0x3ca4(%rip), %xmm0     # 0x6198
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x2b40
movq %rax, -0x40(%rbp)
jmp 0x2507
movq -0x40(%rbp), %rdi
movsd 0x3c8d(%rip), %xmm0     # 0x61a0
xorl %eax, %eax
movl %eax, %esi
callq 0x2b40
movq %rax, -0x48(%rbp)
jmp 0x2522
movq -0x48(%rbp), %rdi
movsd 0x3c7a(%rip), %xmm0     # 0x61a8
xorl %eax, %eax
movl %eax, %esi
callq 0x2b40
movq %rax, -0x50(%rbp)
jmp 0x253d
movq -0x50(%rbp), %rdi
movsd 0x3c67(%rip), %xmm0     # 0x61b0
xorl %eax, %eax
movl %eax, %esi
callq 0x2b40
movq %rax, -0x58(%rbp)
jmp 0x2558
movq -0x58(%rbp), %rdi
movsd 0x3c54(%rip), %xmm0     # 0x61b8
xorl %eax, %eax
movl %eax, %esi
callq 0x2b40
movq %rax, -0x60(%rbp)
jmp 0x2573
movq -0x60(%rbp), %rdi
callq 0x3700
jmp 0x257e
jmp 0x2580
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x24df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3590
jmp 0x25b4
leaq -0x20(%rbp), %rdi
callq 0x3590
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: stevedonovan[P]outstreams/speedtest.cpp
// Function: testwrite_f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void testwrite_f(string file) {
    FILE *out = fopen(file.c_str(),"w");

    for (int i = 0; i < N; i++) {
        fprintf(out,"%g %g %g %g %g\n",x1,x2,x3,x4,x5);
    }

    fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x20a0
movq %rax, %rdi
leaq 0x1a29(%rip), %rsi      # 0x4004
callq 0x2200
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xf4240, -0x14(%rbp)   # imm = 0xF4240
jge 0x2639
movq -0x10(%rbp), %rdi
movsd 0x3b98(%rip), %xmm0     # 0x6198
movsd 0x3b98(%rip), %xmm1     # 0x61a0
movsd 0x3b98(%rip), %xmm2     # 0x61a8
movsd 0x3b98(%rip), %xmm3     # 0x61b0
movsd 0x3b98(%rip), %xmm4     # 0x61b8
leaq 0x19df(%rip), %rsi      # 0x4006
movb $0x5, %al
callq 0x2250
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25eb
movq -0x10(%rbp), %rdi
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x22e0
movl $0x0, -0x20c(%rbp)
cmpl $0xf4240, -0x20c(%rbp)  # imm = 0xF4240
jge 0x27cf
movsd 0x3b03(%rip), %xmm0     # 0x6198
leaq -0x208(%rbp), %rdi
callq 0x22d0
movq %rax, -0x228(%rbp)
jmp 0x26aa
movq -0x228(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x230(%rbp)
jmp 0x26c4
movq -0x230(%rbp), %rdi
movsd 0x3acd(%rip), %xmm0     # 0x61a0
callq 0x22d0
movq %rax, -0x238(%rbp)
jmp 0x26e1
movq -0x238(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x240(%rbp)
jmp 0x26fb
movq -0x240(%rbp), %rdi
movsd 0x3a9e(%rip), %xmm0     # 0x61a8
callq 0x22d0
movq %rax, -0x248(%rbp)
jmp 0x2718
movq -0x248(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x250(%rbp)
jmp 0x2732
movq -0x250(%rbp), %rdi
movsd 0x3a6f(%rip), %xmm0     # 0x61b0
callq 0x22d0
movq %rax, -0x258(%rbp)
jmp 0x274f
movq -0x258(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x260(%rbp)
jmp 0x2769
movq -0x260(%rbp), %rdi
movsd 0x3a40(%rip), %xmm0     # 0x61b8
callq 0x22d0
movq %rax, -0x268(%rbp)
jmp 0x2786
movq -0x268(%rbp), %rdi
movl $0xa, %esi
callq 0x21e0
jmp 0x2799
jmp 0x279b
movl -0x20c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20c(%rbp)
jmp 0x267d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x2270
jmp 0x27e4
leaq -0x208(%rbp), %rdi
callq 0x2270
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x22a0
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 4){
		printUsage(argv[0]);
		return 1;
	}

	const auto op		= argv[1];
	const auto what		= argv[2];
	const auto filename	= argv[3];
	const auto key		= argv[4];
	const auto filename2	= argv[4];

	switch(op[0]){
	case 's':	return op_search_v(
				what[0],
				filename,
				key
			);

	case 'w':	return op_write_v(
				what[0],
				filename,
				filename2
			);
	}
}

// Assembly:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
cmpl $0x4, 0x80(%rsp)
jg 0x26b5
movq 0x78(%rsp), %rax
movq (%rax), %rdi
callq 0x27c0
movl $0x1, 0x84(%rsp)
jmp 0x27aa
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x73, %eax
je 0x271c
jmp 0x270e
movl 0xc(%rsp), %eax
subl $0x77, %eax
je 0x2764
jmp 0x27aa
movq 0x68(%rsp), %rax
movb (%rax), %al
movb %al, 0xb(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x41e0
movq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x41e0
movb 0xb(%rsp), %al
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movsbl %al, %edi
callq 0x28c0
movl %eax, 0x84(%rsp)
jmp 0x27aa
movq 0x68(%rsp), %rax
movb (%rax), %al
movb %al, 0xa(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x41e0
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x41e0
movb 0xa(%rsp), %al
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movsbl %al, %edi
callq 0x2c90
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	printf("Usage:\n");
	printf("\t%s s [class] [file.txt] [key]     - load file.txt, then search for the key\n",		cmd);
	printf("\t%s w [class] [file.txt] [file.db] - load file.txt, then create file.db\n",			cmd);
	printf("Classes are:\n");
	printf("\t%c - %s\n", 't', "std::VectorList");
	printf("\t%c - %s\n", 'v', "VectorList");
	printf("\t%c - %s\n", 'w', "HashList@VectorList bin search");
	printf("\t%c - %s\n", 'l', "LinkList");
	printf("\t%c - %s\n", 's', "SkipList");
	printf("\t%c - %s\n", 'z', "HashList@SkipList");
	printf("\n");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
leaq 0xf958(%rip), %rdi      # 0x12124
movb $0x0, %al
callq 0x2030
movq (%rsp), %rsi
leaq 0xf94e(%rip), %rdi      # 0x1212c
movb $0x0, %al
callq 0x2030
movq (%rsp), %rsi
leaq 0xf989(%rip), %rdi      # 0x12179
movb $0x0, %al
callq 0x2030
leaq 0xf9c4(%rip), %rdi      # 0x121c2
movb $0x0, %al
callq 0x2030
leaq 0xf9c4(%rip), %rdi      # 0x121d0
movl $0x74, %esi
leaq 0xf9c2(%rip), %rdx      # 0x121da
movb $0x0, %al
callq 0x2030
leaq 0xf9aa(%rip), %rdi      # 0x121d0
movl $0x76, %esi
leaq 0xf9ad(%rip), %rdx      # 0x121df
movb $0x0, %al
callq 0x2030
leaq 0xf990(%rip), %rdi      # 0x121d0
movl $0x77, %esi
leaq 0xf99e(%rip), %rdx      # 0x121ea
movb $0x0, %al
callq 0x2030
leaq 0xf976(%rip), %rdi      # 0x121d0
movl $0x6c, %esi
leaq 0xf9a3(%rip), %rdx      # 0x12209
movb $0x0, %al
callq 0x2030
leaq 0xf95c(%rip), %rdi      # 0x121d0
movl $0x73, %esi
leaq 0xf99b(%rip), %rdx      # 0x1221b
movb $0x0, %al
callq 0x2030
leaq 0xf942(%rip), %rdi      # 0x121d0
movl $0x7a, %esi
leaq 0xf978(%rip), %rdx      # 0x12212
movb $0x0, %al
callq 0x2030
leaq 0xf9e5(%rip), %rdi      # 0x1228d
movb $0x0, %al
callq 0x2030
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: op_write_v(char, StringRef const&, StringRef const&)
static int op_write_v(char const what, const StringRef &filename, const StringRef &filename2){
	FileReader reader{ filename };

	switch(what){
	case 'v':
	case 'V':	return op_write(hm3::VectorList{},	reader, filename2);

	case 'l':	return op_write(hm3::LinkList{},	reader, filename2);

	default:
	case 's':	return op_write(hm3::SkipList{},	reader, filename2);
	}
}

// Assembly:
subq $0x4a8, %rsp            # imm = 0x4A8
movb %dil, %al
movb %al, 0x4a3(%rsp)
movq %rsi, 0x498(%rsp)
movq %rdx, 0x490(%rsp)
movq 0x498(%rsp), %rsi
leaq 0x280(%rsp), %rdi
movl $0x3, %edx
callq 0x4230
movsbl 0x4a3(%rsp), %eax
addl $-0x56, %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x20, %eax
ja 0x2e19
movq 0x10(%rsp), %rax
leaq 0xf3ae(%rip), %rcx      # 0x120a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x258(%rsp), %rdi
movl $0x10, %esi
callq 0x9e10
jmp 0x2d0f
movq 0x490(%rsp), %rdx
leaq 0x258(%rsp), %rdi
leaq 0x280(%rsp), %rsi
callq 0x3f80
movl %eax, 0xc(%rsp)
jmp 0x2d32
movl 0xc(%rsp), %eax
movl %eax, 0x4a4(%rsp)
leaq 0x258(%rsp), %rdi
callq 0x4300
movl $0x1, 0x248(%rsp)
jmp 0x2e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0x2eaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x258(%rsp), %rdi
callq 0x4300
jmp 0x2eaa
leaq 0x230(%rsp), %rdi
callq 0xa970
jmp 0x2da8
movq 0x490(%rsp), %rdx
leaq 0x230(%rsp), %rdi
leaq 0x280(%rsp), %rsi
callq 0x4010
movl %eax, 0x8(%rsp)
jmp 0x2dcb
movl 0x8(%rsp), %eax
movl %eax, 0x4a4(%rsp)
leaq 0x230(%rsp), %rdi
callq 0x43d0
movl $0x1, 0x248(%rsp)
jmp 0x2e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x230(%rsp), %rdi
callq 0x43d0
jmp 0x2eaa
jmp 0x2e1b
leaq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0xb530
jmp 0x2e2c
movq 0x490(%rsp), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x280(%rsp), %rsi
callq 0x40a0
movl %eax, 0x4(%rsp)
jmp 0x2e4c
movl 0x4(%rsp), %eax
movl %eax, 0x4a4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb660
movl $0x1, 0x248(%rsp)
jmp 0x2e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xb660
jmp 0x2eaa
leaq 0x280(%rsp), %rdi
callq 0x44a0
movl 0x4a4(%rsp), %eax
addq $0x4a8, %rsp            # imm = 0x4A8
retq
leaq 0x280(%rsp), %rdi
callq 0x44a0
movq 0x250(%rsp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: int op_search<hm3::STLVectorList, FileReader>(hm3::STLVectorList&&, FileReader&, StringRef const&)
static int op_search(LIST &&list, READER &reader, const StringRef &key){
	printf("Load start...\n");
	listLoad(list, reader);
	printf("Load done...\n");
	getchar();

	printf("Search start...\n");
	listSearch(list, key);
	printf("Search done...\n");
	getchar();

	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
leaq 0xf33b(%rip), %rdi      # 0x12224
movb $0x0, %al
callq 0x2030
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x31d0
leaq 0xf328(%rip), %rdi      # 0x12233
movb $0x0, %al
callq 0x2030
callq 0x2320
leaq 0xf323(%rip), %rdi      # 0x12241
movb $0x0, %al
callq 0x2030
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3380
leaq 0xf318(%rip), %rdi      # 0x12252
movb $0x0, %al
callq 0x2030
callq 0x2320
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: void listLoad<hm3::STLVectorList, FileReader>(hm3::STLVectorList&, 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:
subq $0x98, %rsp
movb %dl, %al
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
andb $0x1, %al
movb %al, 0x87(%rsp)
movl $0x0, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4550
testb $0x1, %al
jne 0x3213
jmp 0x3367
movq 0x88(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4570
movq 0x20(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x4680
jmp 0x323b
testb $0x1, 0x87(%rsp)
je 0x3257
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
callq 0x41e0
jmp 0x3255
jmp 0x326b
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x46d0
testb $0x1, %al
jne 0x32ec
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xcd50
jmp 0x32a2
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46f0
jmp 0x32b3
leaq 0x28(%rsp), %rdi
callq 0xcce0
jmp 0x32ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x335b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xcce0
jmp 0x335b
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
movl 0x80(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x334c
movl 0x80(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x90(%rsp), %rdi
callq 0x4720
movq %rax, 0x10(%rsp)
jmp 0x3331
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %esi
leaq 0xef21(%rip), %rdi      # 0x12262
xorl %eax, %eax
callq 0x2030
jmp 0x334a
jmp 0x334c
leaq 0x60(%rsp), %rdi
callq 0x2170
jmp 0x31fd
leaq 0x60(%rsp), %rdi
callq 0x2170
jmp 0x336f
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2400
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: void listSearch<hm3::STLVectorList>(hm3::STLVectorList const&, StringRef const&)
static void listSearch(const LIST &list, const StringRef &key){
	const Pair pair = list.get(key);

	if (! pair){
		printf("Key '%s' not found...\n", key.data());
		return;
	}

	pair.print();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7980
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xce10
leaq 0x10(%rsp), %rdi
callq 0x47a0
testb $0x1, %al
jne 0x33f8
movq 0x18(%rsp), %rdi
callq 0x47c0
movq %rax, %rsi
leaq 0xeec3(%rip), %rdi      # 0x1228f
xorl %eax, %eax
callq 0x2030
jmp 0x33d5
movl $0x1, (%rsp)
jmp 0x3409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xcce0
jmp 0x3418
leaq 0x10(%rsp), %rdi
callq 0xd320
movl $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xcce0
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_file.cc
// Function: int op_write<hm3::VectorList, FileReader>(hm3::VectorList&&, FileReader&, StringRef const&)
static int op_write(LIST &&list, READER &reader, const StringRef &filename2){
	using DiskFileBuilder = hm3::diskfile::DiskFileBuilder;

	printf("Load start...\n");
	listLoad(list, reader);
	printf("Load done...\n");
	getchar();

	printf("Write start...\n");
	DiskFileBuilder df;
	df.createFromList(filename2, list, true);
	printf("Write done...\n");
	getchar();

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0xe28a(%rip), %rdi      # 0x12224
movb $0x0, %al
callq 0x2030
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x3430
leaq 0xe277(%rip), %rdi      # 0x12233
movb $0x0, %al
callq 0x2030
callq 0x2320
leaq 0xe308(%rip), %rdi      # 0x122d7
movb $0x0, %al
callq 0x2030
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xf(%rsp), %rdi
movl $0x1, %ecx
callq 0x6500
leaq 0xe2f1(%rip), %rdi      # 0x122e7
movb $0x0, %al
callq 0x2030
callq 0x2320
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x2310
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x2060
movq %rax, 0x10(%rsp)
jmp 0x45b5
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22c0
movb %al, 0xf(%rsp)
jmp 0x45cf
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x45d9
jmp 0x464d
movq 0x28(%rsp), %rax
movzbl 0x208(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4615
movq 0x18(%rsp), %rdi
callq 0x4730
jmp 0x45f9
jmp 0x4615
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2170
jmp 0x4675
movq 0x28(%rsp), %rax
movzbl 0x208(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x463e
movq 0x18(%rsp), %rdi
callq 0x23c0
testb $0x1, %al
jne 0x4639
jmp 0x463e
jmp 0x459f
movb $0x1, 0x47(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x465a
movb $0x1, 0x47(%rsp)
movl $0x1, 0x30(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x466b
movq 0x18(%rsp), %rdi
callq 0x2170
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2400
nop
// File: 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:
subq $0x6c8, %rsp            # imm = 0x6C8
movb %r8b, %al
movq %rdi, 0x6c0(%rsp)
movq %rsi, 0x6b8(%rsp)
movq %rdx, 0x6b0(%rsp)
movq %rcx, 0x6a8(%rsp)
andb $0x1, %al
movb %al, 0x6a7(%rsp)
movq 0x6c0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x6b8(%rsp), %rdi
callq 0x6840
movq %rax, %rsi
leaq 0x480(%rsp), %rdi
callq 0x44b0
movl $0x10, %edi
movl $0x4, %esi
callq 0x6850
movl %eax, 0x2c(%rsp)
jmp 0x65f2
movl 0x2c(%rsp), %edx
leaq 0x4a0(%rsp), %rdi
leaq 0x480(%rsp), %rsi
callq 0x2450
jmp 0x660d
leaq 0x480(%rsp), %rdi
callq 0x2170
movq 0x6b8(%rsp), %rsi
leaq 0x250(%rsp), %rdi
callq 0x6870
jmp 0x6631
movl $0x10, %edi
movl $0x4, %esi
callq 0x6850
movl %eax, 0x1c(%rsp)
jmp 0x6646
movl 0x1c(%rsp), %edx
leaq 0x270(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0x2450
jmp 0x6661
leaq 0x250(%rsp), %rdi
callq 0x2170
movq 0x6b8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x68f0
jmp 0x6682
movl $0x10, %edi
movl $0x4, %esi
callq 0x6850
movl %eax, 0x18(%rsp)
jmp 0x6697
movl 0x18(%rsp), %edx
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2450
jmp 0x66ac
leaq 0x30(%rsp), %rdi
callq 0x2170
movq 0x20(%rsp), %rdi
movq 0x6b0(%rsp), %rsi
movq 0x6a8(%rsp), %rdx
movzbl 0x6a7(%rsp), %ecx
andl $0x1, %ecx
movq %rsp, %rax
movl %ecx, (%rax)
leaq 0x4a0(%rsp), %rcx
leaq 0x270(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x6970
movb %al, 0x17(%rsp)
jmp 0x66fb
leaq 0x50(%rsp), %rdi
callq 0x2350
leaq 0x270(%rsp), %rdi
callq 0x2350
leaq 0x4a0(%rsp), %rdi
callq 0x2350
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x6c8, %rsp            # imm = 0x6C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
leaq 0x480(%rsp), %rdi
callq 0x2170
jmp 0x67fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
jmp 0x67f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
leaq 0x250(%rsp), %rdi
callq 0x2170
jmp 0x67f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
jmp 0x67e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2170
jmp 0x67e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x478(%rsp)
movl %eax, 0x474(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2350
leaq 0x270(%rsp), %rdi
callq 0x2350
leaq 0x4a0(%rsp), %rdi
callq 0x2350
movq 0x478(%rsp), %rdi
callq 0x2400
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x97d4(%rip), %rdi      # 0xe004
callq 0x4390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x484d
movq -0x18(%rbp), %rax
movq %rax, -0x138(%rbp)
jmp 0x485d
leaq 0x97bf(%rip), %rax      # 0xe013
movq %rax, -0x138(%rbp)
jmp 0x485d
movq -0x138(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq 0x97ae(%rip), %rdi      # 0xe020
callq 0x4390
movq -0x148(%rbp), %rsi
testq %rax, %rax
setne %al
movzbl %al, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x4990
movq -0x140(%rbp), %rsi
leaq -0x100(%rbp), %rdi
movl $0x8000, %edx           # imm = 0x8000
callq 0xa1c0
jmp 0x48b1
leaq -0x130(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x8150
jmp 0x48c6
leaq -0x130(%rbp), %rdi
callq 0x83d0
movb %al, -0x149(%rbp)
jmp 0x48da
movb -0x149(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x8300
leaq -0x100(%rbp), %rdi
callq 0xa4d0
leaq -0x50(%rbp), %rdi
callq 0x4a00
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x496f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x4963
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x8300
leaq -0x100(%rbp), %rdi
callq 0xa4d0
leaq -0x50(%rbp), %rdi
callq 0x4a00
movq -0x108(%rbp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x18873(%rip), %rax     # 0x1b218
movq %rax, 0x30(%rsp)
leaq 0x18867(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x28(%rsp)
leaq 0x18856(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x29e1
jmp 0x2a5b
leaq 0x28(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2ee0
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x2a4a
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2f20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2170
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x29fb
jmp 0x2a4c
leaq 0x28(%rsp), %rdi
callq 0x2f30
jmp 0x29cc
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x2210
leaq 0x1877d(%rip), %rax     # 0x1b218
movq %rax, 0x90(%rsp)
leaq 0x1876e(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x88(%rsp)
leaq 0x1875a(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x2ae6
jmp 0x2b4e
leaq 0x88(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0xb8(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x2f50
movq %rax, 0x38(%rsp)
jmp 0x2b14
movq 0x38(%rsp), %rax
movl $0x0, (%rax)
leaq 0x88(%rsp), %rdi
callq 0x2f30
jmp 0x2acb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x20e0
jmp 0x2cd3
movq 0xc0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x21e0
movq %rax, 0x30(%rsp)
jmp 0x2b6a
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21d0
movb %al, 0x2f(%rsp)
jmp 0x2b84
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x2b91
jmp 0x2cae
movl $0x0, 0x68(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x20(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x2120
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x2cac
movl 0x68(%rsp), %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x22c0
movq %rax, 0x18(%rsp)
jmp 0x2bda
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0x67(%rsp)
leaq 0x1862c(%rip), %rax     # 0x1b218
movq %rax, 0x58(%rsp)
leaq 0x18620(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x50(%rsp)
leaq 0x1860f(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x2c28
jmp 0x2c9a
leaq 0x50(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movsbl 0x67(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2f90
movb %al, 0x17(%rsp)
jmp 0x2c53
movl 0x10(%rsp), %eax
movb 0x17(%rsp), %cl
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2c89
movq 0xb8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2f50
movq %rax, 0x8(%rsp)
jmp 0x2c7b
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2c9a
jmp 0x2c8b
leaq 0x50(%rsp), %rdi
callq 0x2f30
jmp 0x2c13
jmp 0x2c9c
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x2b99
jmp 0x2cae
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0x20e0
movq (%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: ttencate[P]pickomino/game.cc
// Function: operator<(Tile const&, Tile const&)
bool operator<(Tile const &a, Tile const &b) {
  if (a.worms() < b.worms()) return false;
  if (a.worms() > b.worms()) return true;
  if (a.score() < b.score()) return false;
  if (a.score() > b.score()) return true;
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4ad0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4ad0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x38b7
movb $0x0, 0x27(%rsp)
jmp 0x3935
movq 0x18(%rsp), %rdi
callq 0x4ad0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4ad0
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jle 0x38e0
movb $0x1, 0x27(%rsp)
jmp 0x3935
movq 0x18(%rsp), %rdi
callq 0x4ae0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4ae0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3909
movb $0x0, 0x27(%rsp)
jmp 0x3935
movq 0x18(%rsp), %rdi
callq 0x4ae0
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x4ae0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jle 0x3930
movb $0x1, 0x27(%rsp)
jmp 0x3935
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4ae0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x2270
movq %rax, %rdi
movl $0x7c, %esi
callq 0x21c0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4ad0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3a2b
movq 0x20(%rsp), %rdi
movl $0x57, %esi
callq 0x21c0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x39f3
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x170cf(%rip), %rax     # 0x1ab38
movq (%rax), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x3a86
movq 0x177ec(%rip), %rax     # 0x1b268
movq %rax, 0x60(%rsp)
jmp 0x3b76
movq 0x48(%rsp), %rdi
callq 0x4b20
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x44(%rsp)
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4be0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4c10
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4c40
testb $0x1, %al
jne 0x3ad6
jmp 0x3b6a
leaq 0x30(%rsp), %rdi
callq 0x4c80
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x4c90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x3b3e
movq 0x20(%rsp), %rdi
callq 0x4cd0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x3b1a
jmp 0x3b3e
movq 0x20(%rsp), %rdi
callq 0x4cf0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4ae0
cmpl 0x44(%rsp), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3b48
jmp 0x3b59
movq 0x20(%rsp), %rdi
callq 0x4cf0
movq %rax, 0x60(%rsp)
jmp 0x3b76
jmp 0x3b5b
leaq 0x30(%rsp), %rdi
callq 0x4d20
jmp 0x3abe
movq 0x176f7(%rip), %rax     # 0x1b268
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x16f94(%rip), %rax     # 0x1ab38
movq (%rax), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x3bc1
movq 0x176b1(%rip), %rax     # 0x1b268
movq %rax, 0x40(%rsp)
jmp 0x3c5c
movq 0x30(%rsp), %rdi
callq 0x4b20
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x2c(%rsp)
addq $0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4d40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4d70
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4da0
testb $0x1, %al
jne 0x3c12
jmp 0x3c50
leaq 0x18(%rsp), %rdi
callq 0x4dc0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4ae0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x3c42
jmp 0x3c5c
jmp 0x3c44
leaq 0x18(%rsp), %rdi
callq 0x4de0
jmp 0x3bfd
movq 0x17611(%rip), %rax     # 0x1b268
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x1733d(%rip), %rdi     # 0x1afd0
leaq 0xe3ae(%rip), %rsi      # 0x12048
callq 0x2170
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
leaq 0x78(%rsp), %rdi
callq 0x4e10
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
leaq 0x70(%rsp), %rdi
callq 0x4e70
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4e40
testb $0x1, %al
jne 0x3cda
jmp 0x3d1a
movq 0x172ef(%rip), %rdi     # 0x1afd0
movl $0x20, %esi
callq 0x21c0
movq %rax, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4ea0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x39b0
leaq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rsi
xorl %edx, %edx
callq 0x4ed0
jmp 0x3cb2
movq 0x172af(%rip), %rdi     # 0x1afd0
movl $0xa, %esi
callq 0x21c0
movq 0x1729e(%rip), %rdi     # 0x1afd0
movl $0xa, %esi
callq 0x21c0
movq 0x30(%rsp), %rdi
callq 0x4f10
movq %rax, %rdi
callq 0x4f30
movq %rax, %rsi
movq 0x17278(%rip), %rdi     # 0x1afd0
callq 0x2150
movq %rax, %rdi
leaq 0xe2f2(%rip), %rsi      # 0x12059
callq 0x2170
movq 0x30(%rsp), %rdi
callq 0x4f10
movq %rax, %rdi
callq 0x4f50
movq 0x30(%rsp), %rsi
movq %rax, %rdx
leaq 0x50(%rsp), %rdi
callq 0x3e70
movq 0x30(%rsp), %rdi
callq 0x4f10
movq %rax, %rdi
callq 0x4f30
movq %rax, %rsi
movq 0x17224(%rip), %rdi     # 0x1afd0
callq 0x2150
movq %rax, %rdi
leaq 0xe2a7(%rip), %rsi      # 0x12062
callq 0x2170
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4b20
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x2270
movq %rax, %rdi
movl $0xa, %esi
callq 0x21c0
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x41d0
movq 0x30(%rsp), %rdi
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, 0x20(%rsp)
callq 0x4f60
movq %rax, %rcx
movq 0x20(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq 0x30(%rsp), %rax
movl %edx, %ecx
movl %ecx, 0x18(%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x48a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4725
jmp 0x4731
movq 0x8(%rsp), %rdi
callq 0x3c70
jmp 0x4713
movq 0x16898(%rip), %rdi     # 0x1afd0
movl $0xa, %esi
callq 0x21c0
movq 0x16887(%rip), %rdi     # 0x1afd0
leaq 0xd91b(%rip), %rsi      # 0x1206b
callq 0x2170
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4f80
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4fb0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4fe0
testb $0x1, %al
jne 0x4795
jmp 0x488e
leaq 0x40(%rsp), %rdi
callq 0x5020
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4f30
movq %rax, %rsi
movq 0x16818(%rip), %rdi     # 0x1afd0
callq 0x2150
movq %rax, %rdi
movl $0x9, %esi
callq 0x21c0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x5030
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2270
movq %rax, %rdi
movl $0x9, %esi
callq 0x21c0
movq 0x30(%rsp), %rdi
callq 0x50c0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x50d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5100
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5130
testb $0x1, %al
jne 0x4832
jmp 0x486e
leaq 0x20(%rsp), %rdi
callq 0x5170
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x16785(%rip), %rdi     # 0x1afd0
leaq 0x10(%rsp), %rsi
callq 0x39b0
movq %rax, %rdi
movl $0x20, %esi
callq 0x21c0
leaq 0x20(%rsp), %rdi
callq 0x5180
jmp 0x481d
movq 0x1675b(%rip), %rdi     # 0x1afd0
movl $0xa, %esi
callq 0x21c0
leaq 0x40(%rsp), %rdi
callq 0x51a0
jmp 0x477d
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)