LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::getClassificacao[abi:cxx11](std::shared_ptr<Animal>, bool)
string Animal::getClassificacao(shared_ptr<Animal> animal, bool simplificado) {
    if(shared_ptr<Exotico> teste = dynamic_pointer_cast< Exotico >(animal)) {
        if(simplificado)
            return "E";
        else
            return "Silvestre Exótico";
    } if(shared_ptr<Nativo> teste = dynamic_pointer_cast< Nativo >(animal)) {
        if(simplificado)
            return "N";
        else
            return "Silvestre Nativo";
    } else {
        if(simplificado)
            return "D";
        else
            return "Doméstico";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7e1d
cmpq $0x0, (%r15)
je 0x10f9d
testb %bpl, %bpl
je 0x10fd8
leaq 0x820d(%rip), %rsi      # 0x19198
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11033
leaq 0x10(%rsp), %rdi
callq 0x8466
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7e73
cmpq $0x0, (%r15)
je 0x10fee
testb %bpl, %bpl
je 0x11009
leaq 0x81ca(%rip), %rsi      # 0x19193
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11033
leaq 0x7f1e(%rip), %rsi      # 0x18efd
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11033
testb %bpl, %bpl
je 0x1101f
leaq 0x7aab(%rip), %rsi      # 0x18aa5
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11033
leaq 0x7f00(%rip), %rsi      # 0x18f10
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11033
leaq 0x7efb(%rip), %rsi      # 0x18f21
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
leaq 0x10(%rsp), %rdi
callq 0x8466
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11055
jmp 0x11055
jmp 0x11055
jmp 0x11055
jmp 0x11055
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8466
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setClassificacao[abi:cxx11]()
string Animal::setClassificacao() {
    string s;
    cout << endl << "A que categoria o animal pertence?..." << endl;
    cout <<         "D - doméstico" << endl;
    cout <<         "E - exótico"   << endl;
    cout <<         "N - nativo"    << endl;
    getline(cin, s);

    if(s.size() == 0)
        return {};
    else
        switch(toupper(s[0])) {
            case 'D':
                return "D";
                break;
            case 'E':
                return "E";
                break;
            case 'N':
                return "N";
                break;
        }

    return {}; // Não retornou nada (falhou), retorne vazio
    // {} é mais rápido que "", já que não chama o construtor de std::string
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x14f3e(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x7e96(%rip), %rsi      # 0x18f2c
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14f1b(%rip), %rdi     # 0x25fc8
leaq 0x7e9e(%rip), %rsi      # 0x18f52
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14f00(%rip), %rdi     # 0x25fc8
leaq 0x7e92(%rip), %rsi      # 0x18f61
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14ee5(%rip), %rdi     # 0x25fc8
leaq 0x7e84(%rip), %rsi      # 0x18f6e
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14ee2(%rip), %rdi     # 0x25fe0
leaq 0x10(%rsp), %rsi
callq 0x5060
cmpq $0x0, 0x18(%rsp)
je 0x11142
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x1116a
cmpl $0x45, %eax
je 0x11154
cmpl $0x44, %eax
jne 0x11142
leaq 0x7972(%rip), %rsi      # 0x18aa5
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x1117e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x1117e
leaq 0x803d(%rip), %rsi      # 0x19198
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x1117e
leaq 0x8022(%rip), %rsi      # 0x19193
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
leaq 0x10(%rsp), %rdi
callq 0x54c8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x11197
jmp 0x11197
jmp 0x11197
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::getClasse[abi:cxx11](std::shared_ptr<Animal>, bool)
string Animal::getClasse(shared_ptr<Animal> animal, bool simplificado) {
    if(shared_ptr<Ave> teste = dynamic_pointer_cast< Ave >(animal)) {
        if(simplificado)
            return "ave";
        else
            return "Ave";
    } if(shared_ptr<Anfibio> teste = dynamic_pointer_cast< Anfibio >(animal)) {
        if(simplificado)
            return "anf";
        else
            return "Anfíbio";
    } if(shared_ptr<Reptil> teste = dynamic_pointer_cast< Reptil >(animal)) {
        if(simplificado)
            return "rep";
        else
            return "Réptil";
    } else {
        if(simplificado)
            return "mam";
        else
            return "Mamífero";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7ec9
cmpq $0x0, (%r15)
je 0x111ef
testb %bpl, %bpl
je 0x1122d
leaq 0x7dd0(%rip), %rsi      # 0x18fad
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x10(%rsp), %rdi
callq 0x8466
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7f1e
cmpq $0x0, (%r15)
je 0x11246
testb %bpl, %bpl
je 0x11281
leaq 0x5de9(%rip), %rsi      # 0x17004
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x7d45(%rip), %rsi      # 0x18f79
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x10(%rsp), %rdi
callq 0x8466
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7f73
cmpq $0x0, (%r15)
je 0x11297
testb %bpl, %bpl
je 0x112b2
leaq 0x5d9a(%rip), %rsi      # 0x1700c
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x7cf5(%rip), %rsi      # 0x18f7d
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
testb %bpl, %bpl
je 0x112c8
leaq 0x5d65(%rip), %rsi      # 0x17008
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x73f9(%rip), %rsi      # 0x186b2
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x112dc
leaq 0x73eb(%rip), %rsi      # 0x186ba
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
leaq 0x10(%rsp), %rdi
callq 0x8466
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11302
jmp 0x11302
jmp 0x11302
jmp 0x11302
jmp 0x11302
jmp 0x11302
jmp 0x11302
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8466
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setClasse[abi:cxx11]()
string Animal::setClasse() {
    string s;
    cout << endl << "O animal pertence a que classe?..." << endl;
    cout <<         "A - ave"       << endl;
    cout <<         "F - anfíbio"   << endl;
    cout <<         "R - réptil"    << endl;
    cout <<         "M - mamífero"  << endl;
    getline(cin, s);

    if(s.size() == 0)
        return {};
    else
        switch(toupper(s[0])) {
            case 'A':
                return "ave";
                break;
            case 'F':
                return "anf";
                break;
            case 'R':
                return "rep";
                break;
            case 'M':
                return "mam";
                break;
        }

    return {}; // Não retornou nada (falhou), retorne vazio
    // {} é mais rápido que "", já que não chama o construtor de std::string
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x14c90(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x7c42(%rip), %rsi      # 0x18f86
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14c6d(%rip), %rdi     # 0x25fc8
leaq 0x7c47(%rip), %rsi      # 0x18fa9
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14c52(%rip), %rdi     # 0x25fc8
leaq 0x7c34(%rip), %rsi      # 0x18fb1
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14c37(%rip), %rdi     # 0x25fc8
leaq 0x7c26(%rip), %rsi      # 0x18fbe
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14c1c(%rip), %rdi     # 0x25fc8
leaq 0x7c17(%rip), %rsi      # 0x18fca
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x14c19(%rip), %rdi     # 0x25fe0
leaq 0x10(%rsp), %rsi
callq 0x5060
cmpq $0x0, 0x18(%rsp)
je 0x11410
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x52, %eax
je 0x1145f
cmpl $0x46, %eax
je 0x11433
cmpl $0x4d, %eax
je 0x11449
cmpl $0x41, %eax
jne 0x11410
leaq 0x7bac(%rip), %rsi      # 0x18fad
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11420
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x54c8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5bca(%rip), %rsi      # 0x17004
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11420
leaq 0x5bb8(%rip), %rsi      # 0x17008
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11420
leaq 0x5ba6(%rip), %rsi      # 0x1700c
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8226
jmp 0x11420
jmp 0x1147d
jmp 0x1147d
jmp 0x1147d
jmp 0x1147d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/domestico.cpp
// Function: Domestico::setAdestrado()
bool Domestico::setAdestrado() {
    string s;
    cout << endl << "Animal é adestrado? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->adestrado = true;
    else if(toupper(s[0]) == 'N')
        this->adestrado = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x13ff4(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x717a(%rip), %rsi      # 0x1915a
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x13fe9(%rip), %rdi     # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x1201b
movb $0x1, %cl
cmpl $0x53, %eax
je 0x1201d
xorl %ebx, %ebx
jmp 0x12022
xorl %ecx, %ecx
movb %cl, 0x8(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/exotico.cpp
// Function: Exotico::setLocal()
bool Exotico::setLocal() {
    string s;
    cout << endl << "Habitat do animal: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->local = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x13f1e(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x70c1(%rip), %rsi      # 0x19177
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x13f13(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x12121
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x12107
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x6cd0(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x13e76(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/nativo.cpp
// Function: Nativo::setLicenca()
bool Nativo::setLicenca() {
    string s;
    cout << endl << "Licença de transporte IBAMA: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->licenca = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x1160e(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x4df2(%rip), %rsi      # 0x197b8
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x11603(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x14a31
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x14a17
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x43c0(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x11566(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/nativo.cpp
// Function: Nativo::setRegiao()
bool Nativo::setRegiao() {
    string s;
    cout << endl << "Região do animal: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->regiao = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x11520(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x4d23(%rip), %rsi      # 0x197d7
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x11515(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x14b1f
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x14b05
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x42d2(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x11478(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/ave/ave.cpp
// Function: Ave::setVoa()
bool Ave::setVoa() {
    string s;
    cout << endl << "Ave voa? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->voa = true;
    else if(toupper(s[0]) == 'N')
        this->voa = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x1130c(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x4b23(%rip), %rsi      # 0x197eb
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x11301(%rip), %rdi     # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x14d03
movb $0x1, %cl
cmpl $0x53, %eax
je 0x14d05
xorl %ebx, %ebx
jmp 0x14d0d
xorl %ecx, %ecx
movb %cl, 0x89(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/mamifero/mamifero.cpp
// Function: Mamifero::setGestacao()
bool Mamifero::setGestacao() {
    string s;
    cout << endl << "Mamífero possui gestação? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->gestacao = true;
    else if(toupper(s[0]) == 'N')
        this->gestacao = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x10b78(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x43c7(%rip), %rsi      # 0x19823
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x10b6d(%rip), %rdi     # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x15497
movb $0x1, %cl
cmpl $0x53, %eax
je 0x15499
xorl %ebx, %ebx
jmp 0x154a1
xorl %ecx, %ecx
movb %cl, 0x89(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/reptil/reptil.cpp
// Function: Reptil::setPele()
bool Reptil::setPele() {
    string s;
    cout << endl << "Qual o tipo de pele do réptil? (S/N): " << endl;
    cout << "C - carapaça" << endl;
    cout << "E - escama" << endl;
    cout << "P - placa" << endl;
    getline(cin, s);

    switch(toupper(s[0])) {
        case 'C':
            this->pele = Carapaca;
            break;
        case 'E':
            this->pele = Escama;
            break;
        case 'P':
            this->pele = Placa;
            break;
        default:
            return false;
            break;
    }

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x103e6(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x3c91(%rip), %rsi      # 0x1987f
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x103c3(%rip), %rdi     # 0x25fc8
leaq 0x3c9b(%rip), %rsi      # 0x198a7
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x103a8(%rip), %rdi     # 0x25fc8
leaq 0x3c8e(%rip), %rsi      # 0x198b5
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x1038d(%rip), %rdi     # 0x25fc8
leaq 0x3c7e(%rip), %rsi      # 0x198c0
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x1038a(%rip), %rdi     # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x43, %eax
je 0x15c81
cmpl $0x45, %eax
je 0x15c7d
cmpl $0x50, %eax
jne 0x15c8e
pushq $0x1
jmp 0x15c83
xorl %eax, %eax
jmp 0x15c84
pushq $0x2
popq %rax
movl %eax, 0x8c(%rbx)
movb $0x1, %bl
jmp 0x15c90
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/anfibio/anfibio.cpp
// Function: Anfibio::setCauda()
bool Anfibio::setCauda() {
    string s;
    cout << endl << "Anfíbio possui cauda? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->cauda = true;
    else if(toupper(s[0]) == 'N')
        this->cauda = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xfbf0(%rip), %rdi      # 0x25fc8
callq 0x5160
leaq 0x3517(%rip), %rsi      # 0x198fb
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0xfbe5(%rip), %rdi      # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x1641f
movb $0x1, %cl
cmpl $0x53, %eax
je 0x16421
xorl %ebx, %ebx
jmp 0x16429
xorl %ecx, %ecx
movb %cl, 0x89(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/anfibio/anfibio.cpp
// Function: Anfibio::setPata()
bool Anfibio::setPata() {
    string s;
    cout << endl << "Anfíbio possui pata? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->pata = true;
    else if(toupper(s[0]) == 'N')
        this->pata = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xfb4c(%rip), %rdi      # 0x25fc8
callq 0x5160
leaq 0x3492(%rip), %rsi      # 0x1991a
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0xfb41(%rip), %rdi      # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x164c3
movb $0x1, %cl
cmpl $0x53, %eax
je 0x164c5
xorl %ebx, %ebx
jmp 0x164cd
xorl %ecx, %ecx
movb %cl, 0x8a(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::StringWriter::write(unsigned long, void const*)
size_t write(size_t length, const void* data) override
        {
            if (m_length >= 0) {
                m_length += int32_t(length);

                if (m_size) {
                    const auto toCopy = std::min(size_t(m_size), length);
                    std::memcpy(m_buffer, data, toCopy);
                    m_buffer += toCopy;
                    m_size -= int32_t(toCopy);
                    return toCopy;
                }
            }

            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x14(%rdi), %eax
testl %eax, %eax
js 0xd7e6
movq %rsi, %rbx
movq %rdi, %r14
addl %ebx, %eax
movl %eax, 0x14(%rdi)
movslq 0x10(%rdi), %rax
testq %rax, %rax
je 0xd7e6
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq 0x8(%r14), %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x1070
addq %rbx, 0x8(%r14)
subl %ebx, 0x10(%r14)
jmp 0xd7e8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, long long)
inline bool format_value(IWriter& writer, const StringView& fmt, long long value)
    {
        static_assert(sizeof(value) == sizeof(uint64_t), "invalid cast on negation");

        const auto abs = (value >= 0 || value == std::numeric_limits<long long>::min())
            ? uint64_t(value)
            : uint64_t(-value);

        FormatFlags flags;

        return parse_format(fmt, &flags)
            && format_int(writer, flags, value < 0, abs);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
orl $-0x1, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xe961
testb %al, %al
je 0xe956
movq %rbx, %rcx
negq %rcx
cmovsq %rbx, %rcx
shrq $0x3f, %rbx
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0xec15
jmp 0xe958
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, char32_t)
inline bool format_value(IWriter& writer, const StringView& fmt, char32_t value)
    {
        FormatFlags flags;

        if (parse_format(fmt, &flags)) {
            if (!flags.type) {
                flags.type = 'c';
            }

            if (!flags.align) {
                flags.align = '<';
            }

            return format_int(writer, flags, false, uint64_t(value));
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %rbx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
orl $-0x1, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xe961
testb %al, %al
je 0xf68f
cmpb $0x0, -0x14(%rbp)
jne 0xf672
movb $0x63, -0x14(%rbp)
cmpb $0x0, -0x1f(%rbp)
jne 0xf67c
movb $0x3c, -0x1f(%rbp)
movl %r14d, %ecx
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xec15
jmp 0xf691
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: bool sp::format_index<float, char const (&) [8]>(sp::IWriter&, sp::StringView const&, int, float&&, char const (&) [8])
bool format_index(IWriter& writer, const StringView& format, int32_t index, Arg&& arg, Rest&&... rest)
    {
        if (!index) {
            return format_value(writer, format, std::forward<Arg>(arg));
        } else {
            return format_index(writer, format, index - 1, std::forward<Rest>(rest)...);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
je 0xfa35
decl %edx
movq %r8, %rcx
popq %rbp
jmp 0xfa3f
movss (%rcx), %xmm0
popq %rbp
jmp 0xfa54
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, sp::StringView const&)
inline bool format_value(IWriter& writer, const StringView& fmt, const StringView& value)
    {
        FormatFlags flags;

        return parse_format(fmt, &flags)
            ? format_string(writer, flags, value)
            : false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
orl $-0x1, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xe961
testb %al, %al
je 0xfdda
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xfde5
jmp 0xfddc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, bool)
inline bool format_value(IWriter& writer, const StringView& fmt, bool value)
    {
        FormatFlags flags;

        if (parse_format(fmt, &flags)) {
            switch (flags.type) {
                case 'b':
                case 'c':
                case 'd':
                case 'o':
                case 'x':
                case 'X':
                    return format_int(writer, flags, false, (uint64_t)value);
                default:
                    return format_string(writer, flags, value ? "true" : "false");
            }
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %rbx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
orl $-0x1, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xe961
testb %al, %al
je 0x11161
movzbl -0x14(%rbp), %eax
addl $-0x58, %eax
cmpl $0x20, %eax
ja 0x1116c
movabsq $0x100801c01, %rcx      # imm = 0x100801C01
btq %rax, %rcx
jae 0x1116c
movzbl %r14b, %ecx
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xec15
jmp 0x11163
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8741(%rip), %rax      # 0x198b4
leaq 0x8e17(%rip), %rcx      # 0x19f91
testb %r14b, %r14b
cmovneq %rax, %rcx
leaq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
movzbl %r14b, %eax
xorl $0x5, %eax
movl %eax, 0x8(%rdx)
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xfde5
jmp 0x1115f
// File: /workspace/github_cpp_makefile_star2_O2/rhoot[P]sp/tests/../include/sp.hpp
// Function: bool sp::format_value<void>(sp::IWriter&, sp::StringView const&, void*)
bool format_value(IWriter& writer, const StringView& fmt, T* value)
    {
        FormatFlags flags;

        if (parse_format(fmt, &flags)) {
            if (!flags.type) {
                flags.type = 'x';
            }

            return format_int(writer, flags, false, uint64_t(value));
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
orl $-0x1, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xe961
testb %al, %al
je 0x15ace
cmpb $0x0, -0x14(%rbp)
jne 0x15abb
movb $0x78, -0x14(%rbp)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xec15
jmp 0x15ad0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AlanReviews[P]Goblet-of-fire/Control.cc
// Function: Control::drawParticipant(std::vector<Participant, std::allocator<Participant>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Control::drawParticipant(vector<Participant> candidates, string school) {
    int candidateNum = rand() % candidates.size();
    while (candidates[candidateNum].getSchool() != school) {
        candidateNum = rand() % candidates.size();
    }
    candidates[candidateNum].displayInfo();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
callq 0x2040
pushq $0x48
popq %r13
leaq 0x8(%rsp), %r15
movslq %eax, %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r13
movq %rax, %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movslq %edx, %rax
imulq $0x48, %rax, %r12
addq %r12, %rsi
movq %r15, %rdi
callq 0x2ed8
movq %r15, %rdi
movq %r14, %rsi
callq 0x290d
movl %eax, %ebp
movq %r15, %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x2440
callq 0x2040
jmp 0x23f0
addq (%rbx), %r12
movq %r12, %rdi
callq 0x2eea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AlanReviews[P]Goblet-of-fire/View.cc
// Function: View::displayMenu(int&)
void View::displayMenu(int& choice)
{
  cout << "Welcome to the Goblet of Fire"<< endl;
  cout << "Remember, when you enter your name, you must participate in the Triwizard Tournament otherwise your magic will be gone" << endl;
  cout << "  1. Enter a participant:" << endl;
  cout << "  2. Draw out:" << endl;
  cout << "  0. Exit" << endl<<endl;

  cout << "Enter your selection: ";
  cin >> choice;
  if (choice == 0)
    return;

  while (choice < 0 || choice > 2) {
    cout << "Enter your selection: ";
    cin >> choice;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x3016(%rip), %r14      # 0x5fd0
leaq 0x11f0(%rip), %rsi      # 0x41b1
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x11f7(%rip), %rsi      # 0x41cf
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1257(%rip), %rsi      # 0x4246
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x125a(%rip), %rsi      # 0x4260
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1252(%rip), %rsi      # 0x426f
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20c0
leaq 0x123d(%rip), %rsi      # 0x4279
movq %r14, %rdi
callq 0x2180
movq 0x2f95(%rip), %rdi      # 0x5fe0
movq %rbx, %rsi
callq 0x20f0
cmpl $0x3, (%rbx)
jb 0x3088
movq 0x2f71(%rip), %r14      # 0x5fd0
leaq 0x1213(%rip), %r15      # 0x4279
movq 0x2f73(%rip), %r12      # 0x5fe0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %r12, %rdi
movq %rbx, %rsi
callq 0x20f0
cmpl $0x2, (%rbx)
ja 0x306d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::LoadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<unsigned char, std::allocator<unsigned char>>&)
bool LoadFile(const std::string* path, std::vector<unsigned char>& buffer) {
        std::ifstream file(path->c_str(), std::fstream::binary);

        if (file) {
            std::noskipws(file);

            file.seekg(0, file.end);
            uint64_t len = file.tellg();
            file.seekg(0, file.beg);

            buffer.resize(len, 0u);
            std::copy(std::istream_iterator<unsigned char>(file),
                      std::istream_iterator<unsigned char>(),
                      &buffer[0]);

            file.close();
            return true;
        }

        return false;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x28(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x22f0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x48(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x2594
andb $-0x11, 0x41(%rsp,%rax)
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x2230
leaq 0x28(%rsp), %rdi
callq 0x22d0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2230
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3558
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x35ba
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
andw $0x0, 0x8(%rsi)
movq (%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x3586
leaq 0x28(%rsp), %rdi
callq 0x2050
testb $0x5, %bpl
sete %bl
leaq 0x28(%rsp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x25b9
jmp 0x25b9
jmp 0x25b9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::SaveFile(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*)
bool SaveFile(const std::vector<unsigned char>& Buffer, const std::string *Path) {
        std::ofstream file(Path->c_str(), std::fstream::binary);
        std::noskipws(file);
        file.write(reinterpret_cast<const char *>(&Buffer[0]), Buffer.size());
        file.close();
        return file ? true : false;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x20(%rsp,%rax) # imm = 0xFFFFEFFF
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x2210
leaq 0x8(%rsp), %rdi
callq 0x2250
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
sete %bl
callq 0x2270
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::ComputeProbabilities(unsigned int*, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char)
void ComputeProbabilities(uint32_t* ProbabilityTable, std::vector<unsigned char>& UncompressedBuffer, uint8_t BitShift) {
        memset(ProbabilityTable, 0u, 256*4);
        uint8_t val;

        for (uint32_t i = 0; i < MIN(UncompressedBuffer.size() - 1, UINT32_MAX); i++) {
            val = ((uint8_t) UncompressedBuffer[i] << BitShift) +
                  ((uint8_t) UncompressedBuffer[i + 1] >> (8 - BitShift));
            ProbabilityTable[val]++;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x20f0
movq (%r15), %rdx
movq %rdx, %rsi
notq %rsi
addq 0x8(%r15), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rsi
cmovaeq %rax, %rsi
pushq $0x8
popq %rax
subl %ebx, %eax
cmpl %esi, %r12d
jae 0x26bc
movzbl (%rdx,%r12), %edi
movl %ebx, %ecx
shll %cl, %edi
incq %r12
movl %r12d, %ecx
movzbl (%rdx,%rcx), %r8d
movl %eax, %ecx
shrl %cl, %r8d
addl %edi, %r8d
movzbl %r8b, %ecx
incl (%r14,%rcx,4)
jmp 0x2691
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::ArithmeticMean(unsigned int const*, unsigned long)
double ArithmeticMean(const uint32_t* Data, uint64_t Size) {
        double sum = 0;

        for (uint64_t i = 0; i < Size; i++) {
            sum += double(*(Data+i));
        }

        return sum / (double) Size;
    }

// Assembly:
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %rsi
je 0x26e4
movl (%rdi,%rax,4), %ecx
cvtsi2sd %rcx, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x26ce
movq %rsi, %xmm1
punpckldq 0x591f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5927(%rip), %xmm1     # 0x8020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::StandardDeviation(unsigned int const*, unsigned long)
double StandardDeviation(const uint32_t* Data, uint64_t Size) {
        double mean = ArithmeticMean(Data, Size);
        double sum = 0;

        for (uint64_t i = 0; i < Size; i++) {
            sum += pow((double(*(Data+i)) - mean), 2);
        }

        return sqrt(sum / ((double) Size - 1));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26c8
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %rbx
je 0x2742
movl (%r14,%rax,4), %ecx
cvtsi2sd %rcx, %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
jmp 0x2723
movq %rbx, %xmm1
punpckldq 0x58c1(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x58c9(%rip), %xmm1     # 0x8020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
addsd 0x58c5(%rip), %xmm2     # 0x8030
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2785
sqrtsd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressBuffer(std::vector<unsigned char, std::allocator<unsigned char>>&, buffer::CodecByteStream&)
CodecStatusCode CompressBuffer(std::vector<unsigned char>& UncompressedBuffer, buffer::CodecByteStream& CompressedBuffer) {
        std::cout << "Initializing Compressor..." << std::endl;
        CodecProbabilityTable ProbabilityTable;
        ProbabilityTable.GenerateTable(UncompressedBuffer);
        CompressBuffer(UncompressedBuffer, ProbabilityTable, CompressedBuffer);
        uint64_t UncompressedBufferSize = UncompressedBuffer.size();
        buffer::EncodeTypeToBuffer<uint64_t>(CompressedBuffer.GetBuffer(), 0, &UncompressedBufferSize);
        ProbabilityTable.EncodeToBuffer(CompressedBuffer.GetBuffer(), 8);
        return Success;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa169(%rip), %rdi      # 0xcfc8
leaq 0x5216(%rip), %rsi      # 0x807c
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %r15
movl $0x404, %edx            # imm = 0x404
movq %r15, %rdi
xorl %esi, %esi
callq 0x20f0
movq %r15, %rdi
movq %r14, %rsi
callq 0x37ea
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2791
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x38de
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38fa
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::UncompressBuffer(buffer::CodecByteStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
CodecStatusCode UncompressBuffer(buffer::CodecByteStream& UncompressedBuffer, std::vector<unsigned char>& CompressedBuffer) {
        std::cout << "Initializing Uncompressor..." << std::endl;
        uint64_t UncompressedBufferSize;
        CodecProbabilityTable ProbabilityTable;

        buffer::DecodeTypeFromBuffer<uint64_t>(CompressedBuffer, 0, &UncompressedBufferSize);
        ProbabilityTable.DecodeFromBuffer(CompressedBuffer, 8);

        UncompressBuffer(CompressedBuffer,
                         ProbabilityTable,
                         UncompressedBuffer,
                         UncompressedBufferSize);

        UncompressedBuffer.TruncateOne();

        return Success;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0d9(%rip), %rdi      # 0xcfc8
leaq 0x51a1(%rip), %rsi      # 0x8097
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
leaq 0x10(%rsp), %r15
movl $0x404, %edx            # imm = 0x404
movq %r15, %rdi
xorl %esi, %esi
callq 0x20f0
leaq 0x8(%rsp), %r12
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x393d
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3958
movq (%r12), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2a61
movq %rbx, %rdi
callq 0x399c
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(256*4+8);
            arith::CompressBuffer(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x24ec
testb %al, %al
je 0x2fda
leaq 0x20(%rsp), %rdi
movl $0x408, %esi            # imm = 0x408
callq 0x39ba
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e46
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x25ce
xorl %ebx, %ebx
testb %al, %al
jne 0x2fce
movq 0xa031(%rip), %rdi      # 0xcfe8
leaq 0x50f6(%rip), %rsi      # 0x80b4
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x2
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x2ff8
movq 0xa007(%rip), %rdi      # 0xcfe8
leaq 0x50de(%rip), %rsi      # 0x80c6
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rbx
movq %rsp, %rdi
callq 0x44a6
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3019
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x301c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x44a6
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./arith.h
// Function: arith::UncompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode UncompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> CompressedBuffer;

        if (buffer::LoadFile(&InFile, CompressedBuffer)) {
            buffer::CodecByteStream UncompressedBuffer(0);
            try {
                arith::UncompressBuffer(UncompressedBuffer, CompressedBuffer);
            } catch (std::exception& e) {
                std::cerr << e.what() << std::endl;
                return BadCompressionStream;
            }

            if (buffer::SaveFile(UncompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x24ec
testb %al, %al
je 0x30a1
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x39ba
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2ed4
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x25ce
xorl %ebx, %ebx
testb %al, %al
jne 0x3095
movq 0x9f6a(%rip), %rdi      # 0xcfe8
leaq 0x502f(%rip), %rsi      # 0x80b4
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x2
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x30bf
movq 0x9f40(%rip), %rdi      # 0xcfe8
leaq 0x5017(%rip), %rsi      # 0x80c6
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rbx
movq %rsp, %rdi
callq 0x44a6
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x3121
movq %rbx, %rdi
callq 0x20b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x9ef9(%rip), %rdi      # 0xcfe8
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
callq 0x22b0
pushq $0x3
jmp 0x3094
jmp 0x311e
movq %rax, %rbx
callq 0x22b0
jmp 0x3121
movq %rax, %rdi
callq 0x3a06
jmp 0x312d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x3130
movq %rax, %rbx
movq %rsp, %rdi
callq 0x44a6
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(2+8+256*(1+8));
            CompressBuffer<unsigned char, uint64_t>(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x24ec
testb %al, %al
je 0x31b8
leaq 0x20(%rsp), %rdi
movl $0x90a, %esi            # imm = 0x90A
callq 0x39ba
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x3a11
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x25ce
xorl %ebx, %ebx
testb %al, %al
jne 0x31ac
movq 0x9e53(%rip), %rdi      # 0xcfe8
leaq 0x4f18(%rip), %rsi      # 0x80b4
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x2
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x31d6
movq 0x9e29(%rip), %rdi      # 0xcfe8
leaq 0x4f00(%rip), %rsi      # 0x80c6
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rbx
movq %rsp, %rdi
callq 0x44a6
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x31f7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x44a6
jmp 0x31fa
movq %rax, %rbx
movq %rsp, %rdi
callq 0x44a6
movq %rbx, %rdi
callq 0x22e0