LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: brashi[P]PetFera/src/funcionarios/veterinario.cpp
// Function: Veterinario::setCRMV()
bool Veterinario::setCRMV() {
    string s;
    cout << endl << "CRMV: " << 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->CRMV = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x3a394(%rip), %rdi     # 0x62fc8
movq 0x3a365(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x28c46
movq -0x48(%rbp), %rdi
leaq 0x195b9(%rip), %rsi     # 0x4220a
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x28c5c
movq -0x58(%rbp), %rdi
movq 0x3a339(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x28c6e
movq 0x3a36b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x28c80
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x28cd8
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x192d4(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x3a2f2(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x28d31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x28d28
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x28cf4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x28d14
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x28d07
jmp 0x28d09
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setEspecie()
bool Animal::setEspecie() {
    string s;
    cout << endl << "Espécie: " << 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->especie = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x39624(%rip), %rdi     # 0x62fc8
movq 0x395f5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x299b6
movq -0x48(%rbp), %rdi
leaq 0x186bf(%rip), %rsi     # 0x42080
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x299cc
movq -0x58(%rbp), %rdi
movq 0x395c9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x299de
movq 0x395fb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x299f0
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x29a48
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x18564(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x39582(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x29aa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x29a98
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x29a64
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x29a84
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x29a77
jmp 0x29a79
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setAmeacadoPor()
bool Animal::setAmeacadoPor() {
    string s;
    cout << endl << "Animal ameaçado de extinção por?: " << 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->ameacadoPor = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x39494(%rip), %rdi     # 0x62fc8
movq 0x39465(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x29b46
movq -0x48(%rbp), %rdi
leaq 0x1853a(%rip), %rsi     # 0x4208b
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x29b5c
movq -0x58(%rbp), %rdi
movq 0x39439(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x29b6e
movq 0x3946b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x29b80
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x29bd8
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x183d4(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x393f2(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x29c31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x29c28
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x29bf4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x29c14
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x29c07
jmp 0x29c09
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setPerigoso()
bool Animal::setPerigoso() {
    string s;
    cout << endl << "É perigoso? (S/N): ";
    getline(cin, s);
    
    if(toupper(s[0]) == 'S')
        this->perigoso = true;
    else if(toupper(s[0]) == 'N')
        this->perigoso = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x39254(%rip), %rdi     # 0x62fc8
movq 0x39225(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x29d86
movq -0x48(%rbp), %rdi
leaq 0x18320(%rip), %rsi     # 0x420b1
callq 0x6310
jmp 0x29d98
movq 0x39241(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x29daa
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x58(%rbp)
jmp 0x29dbd
movq -0x58(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x29df2
movq -0x50(%rbp), %rax
movb $0x1, 0x88(%rax)
jmp 0x29e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x29e51
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x29e05
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x29e23
movq -0x50(%rbp), %rax
movb $0x0, 0x88(%rax)
jmp 0x29e30
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x29e3d
jmp 0x29e32
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x36e14(%rip), %rdi     # 0x62fc8
movq 0x36de5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x2c1c6
movq -0x48(%rbp), %rdi
leaq 0x16152(%rip), %rsi     # 0x42323
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x2c1dc
movq -0x58(%rbp), %rdi
movq 0x36db9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x2c1ee
movq 0x36deb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x2c200
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x2c213
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x2c245
movq -0x50(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x2c282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x2c2a1
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x68(%rbp)
jmp 0x2c258
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x2c273
movq -0x50(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0x2c280
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x2c28d
jmp 0x2c282
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x36c24(%rip), %rdi     # 0x62fc8
movq 0x36bf5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x2c3b6
movq -0x48(%rbp), %rdi
leaq 0x15f7f(%rip), %rsi     # 0x42340
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x2c3cc
movq -0x58(%rbp), %rdi
movq 0x36bc9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x2c3de
movq 0x36bfb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x2c3f0
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x2c448
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x15b64(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x36b82(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x2c4a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x2c498
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x2c464
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x2c484
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x2c477
jmp 0x2c479
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x274e4(%rip), %rdi     # 0x62fc8
movq 0x274b5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3baf6
movq -0x48(%rbp), %rdi
leaq 0x6fc0(%rip), %rsi      # 0x42ac1
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3bb0c
movq -0x58(%rbp), %rdi
movq 0x27489(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3bb1e
movq 0x274bb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3bb30
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x3bb88
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x6424(%rip), %rax      # 0x41f80
movq %rax, (%rdi)
movq 0x27442(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x3bbe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3bbd8
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x3bba4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3bbc4
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x3bbb7
jmp 0x3bbb9
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x27354(%rip), %rdi     # 0x62fc8
movq 0x27325(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3bc86
movq -0x48(%rbp), %rdi
leaq 0x6e4f(%rip), %rsi      # 0x42ae0
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3bc9c
movq -0x58(%rbp), %rdi
movq 0x272f9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3bcae
movq 0x2732b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3bcc0
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x3bd18
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x6294(%rip), %rax      # 0x41f80
movq %rax, (%rdi)
movq 0x272b2(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x3bd71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3bd68
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x3bd34
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3bd54
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x3bd47
jmp 0x3bd49
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x26ff4(%rip), %rdi     # 0x62fc8
movq 0x26fc5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3bfe6
movq -0x48(%rbp), %rdi
leaq 0x6b03(%rip), %rsi      # 0x42af4
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3bffc
movq -0x58(%rbp), %rdi
movq 0x26f99(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3c00e
movq 0x26fcb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3c020
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x3c033
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x3c068
movq -0x50(%rbp), %rax
movb $0x1, 0x89(%rax)
jmp 0x3c0a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3c0c7
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x68(%rbp)
jmp 0x3c07b
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x3c099
movq -0x50(%rbp), %rax
movb $0x0, 0x89(%rax)
jmp 0x3c0a6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3c0b3
jmp 0x3c0a8
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x26314(%rip), %rdi     # 0x62fc8
movq 0x262e5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3ccc6
movq -0x48(%rbp), %rdi
leaq 0x5e5b(%rip), %rsi      # 0x42b2c
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3ccdc
movq -0x58(%rbp), %rdi
movq 0x262b9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3ccee
movq 0x262eb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3cd00
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x3cd13
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x3cd48
movq -0x50(%rbp), %rax
movb $0x1, 0x89(%rax)
jmp 0x3cd88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3cda7
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x68(%rbp)
jmp 0x3cd5b
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x3cd79
movq -0x50(%rbp), %rax
movb $0x0, 0x89(%rax)
jmp 0x3cd86
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3cd93
jmp 0x3cd88
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x25651(%rip), %rdi     # 0x62fc8
movq 0x25622(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3d989
movq -0x48(%rbp), %rdi
leaq 0x51f4(%rip), %rsi      # 0x42b88
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3d99f
movq -0x58(%rbp), %rdi
movq 0x255f6(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3d9b1
movq 0x25610(%rip), %rdi     # 0x62fc8
leaq 0x51f1(%rip), %rsi      # 0x42bb0
callq 0x6310
movq %rax, -0x60(%rbp)
jmp 0x3d9ca
movq -0x60(%rbp), %rdi
movq 0x255cb(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3d9dc
movq 0x255e5(%rip), %rdi     # 0x62fc8
leaq 0x51d4(%rip), %rsi      # 0x42bbe
callq 0x6310
movq %rax, -0x68(%rbp)
jmp 0x3d9f5
movq -0x68(%rbp), %rdi
movq 0x255a0(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3da07
movq 0x255ba(%rip), %rdi     # 0x62fc8
leaq 0x51b4(%rip), %rsi      # 0x42bc9
callq 0x6310
movq %rax, -0x70(%rbp)
jmp 0x3da20
movq -0x70(%rbp), %rdi
movq 0x25575(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3da32
movq 0x255a7(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3da44
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x78(%rbp)
jmp 0x3da57
movq -0x78(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
movl %eax, %ecx
movl %ecx, -0x7c(%rbp)
subl $0x43, %eax
je 0x3da9a
jmp 0x3da6f
movl -0x7c(%rbp), %eax
subl $0x45, %eax
je 0x3daaa
jmp 0x3da79
movl -0x7c(%rbp), %eax
subl $0x50, %eax
je 0x3daba
jmp 0x3daca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3daf9
movq -0x50(%rbp), %rax
movl $0x2, 0x8c(%rax)
jmp 0x3dad7
movq -0x50(%rbp), %rax
movl $0x0, 0x8c(%rax)
jmp 0x3dad7
movq -0x50(%rbp), %rax
movl $0x1, 0x8c(%rax)
jmp 0x3dad7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3dae2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x24914(%rip), %rdi     # 0x62fc8
movq 0x248e5(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3e6c6
movq -0x48(%rbp), %rdi
leaq 0x4533(%rip), %rsi      # 0x42c04
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3e6dc
movq -0x58(%rbp), %rdi
movq 0x248b9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3e6ee
movq 0x248eb(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3e700
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x3e713
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x3e748
movq -0x50(%rbp), %rax
movb $0x1, 0x89(%rax)
jmp 0x3e788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3e7a7
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x68(%rbp)
jmp 0x3e75b
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x3e779
movq -0x50(%rbp), %rax
movb $0x0, 0x89(%rax)
jmp 0x3e786
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3e793
jmp 0x3e788
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x247a4(%rip), %rdi     # 0x62fc8
movq 0x24775(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x3e836
movq -0x48(%rbp), %rdi
leaq 0x43e2(%rip), %rsi      # 0x42c23
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x3e84c
movq -0x58(%rbp), %rdi
movq 0x24749(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x3e85e
movq 0x2477b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x3e870
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x60(%rbp)
jmp 0x3e883
movq -0x60(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x53, %eax
jne 0x3e8b8
movq -0x50(%rbp), %rax
movb $0x1, 0x8a(%rax)
jmp 0x3e8f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x3e917
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x68(%rbp)
jmp 0x3e8cb
movq -0x68(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
cmpl $0x4e, %eax
jne 0x3e8e9
movq -0x50(%rbp), %rax
movb $0x0, 0x8a(%rax)
jmp 0x3e8f6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3e903
jmp 0x3e8f8
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
// File: rhoot[P]sp/tests/main.cpp
// Function: format_value(sp::IWriter&, sp::StringView const&, Foo const&)
static bool format_value(sp::IWriter& writer, const sp::StringView& format, const Foo&)
{
    if (!format.length) {
        writer.write(7, "<empty>");
    } else {
        writer.write(format.length, format.ptr);
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x13e95
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movl $0x7, %esi
leaq 0x11a1e(%rip), %rdx     # 0x258af
callq *(%rax)
jmp 0x13ead
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq (%rdi), %rax
callq *(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x14(%rax)
jl 0x13fa8
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x10(%rax)
je 0x13fa6
movq -0x38(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10b0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13fb0
jmp 0x13fa8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::StreamWriter::write(unsigned long, void const*)
size_t write(size_t length, const void* data) override
        {
            if (m_length >= 0) {
                const auto written = std::fwrite(data, 1, length, m_stream);

                if (written == length) {
                    m_length += int32_t(written);
                } else {
                    m_length = -1;
                }

                return written;
            }

            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x10(%rax)
jl 0x14faf
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x1160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x14f9a
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x14fa5
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14fb7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x15994
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x15a10
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x1599e
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x159a8
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15a20
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15a50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x159d4
jmp 0x159f6
movq -0x8(%rbp), %rdi
cmpq $0x0, -0x18(%rbp)
setl %al
movq -0x20(%rbp), %rcx
movzbl %al, %edx
andl $0x1, %edx
leaq -0x30(%rbp), %rsi
callq 0x15dc0
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x15a20
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x15a50
testb $0x1, %al
jne 0x16f0f
jmp 0x16f3e
cmpb $0x0, -0x20(%rbp)
jne 0x16f19
movb $0x63, -0x20(%rbp)
cmpb $0x0, -0x2b(%rbp)
jne 0x16f23
movb $0x3c, -0x2b(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq 0x15dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x16f42
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x15a20
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15a50
testb $0x1, %al
jne 0x17b20
jmp 0x17b36
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x17b50
movb %al, -0x29(%rbp)
jmp 0x17b3d
xorl %eax, %eax
movb %al, -0x29(%rbp)
jmp 0x17b3d
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x15a20
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x15a50
testb $0x1, %al
jne 0x195d6
jmp 0x19666
movsbl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x58, %eax
je 0x19605
jmp 0x195e4
movl -0x44(%rbp), %eax
addl $-0x62, %eax
subl $0x3, %eax
jb 0x19605
jmp 0x195f1
movl -0x44(%rbp), %eax
subl $0x6f, %eax
je 0x19605
jmp 0x195fb
movl -0x44(%rbp), %eax
subl $0x78, %eax
jne 0x19625
jmp 0x19605
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq 0x15dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1966a
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb -0x19(%rbp), %cl
leaq 0xaef9(%rip), %rsi      # 0x24530
leaq 0xa815(%rip), %rax      # 0x23e53
testb $0x1, %cl
cmovneq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x14060
movq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x17b50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1966a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15a20
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15a50
testb $0x1, %al
jne 0x1fa30
jmp 0x1fa54
cmpb $0x0, -0x24(%rbp)
jne 0x1fa3a
movb $0x78, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x15dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fa58
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2060
movq -0x50(%rbp), %rdi
cltq
movq %rax, -0x48(%rbp)
callq 0x2d60
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2dc0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4540
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2d90
movb %al, -0x59(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x25bc
jmp 0x25e3
callq 0x2060
movq -0x50(%rbp), %rdi
cltq
movq %rax, -0x68(%rbp)
callq 0x2d60
movq %rax, %rcx
movq -0x68(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2581
movq -0x50(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2dc0
movq %rax, %rdi
callq 0x4570
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3939(%rip), %rdi      # 0x7fd0
leaq 0xb13(%rip), %rsi       # 0x51b1
callq 0x21c0
movq %rax, %rdi
movq 0x3913(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq 0x3917(%rip), %rdi      # 0x7fd0
leaq 0xb0f(%rip), %rsi       # 0x51cf
callq 0x21c0
movq %rax, %rdi
movq 0x38f1(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq 0x38f5(%rip), %rdi      # 0x7fd0
leaq 0xb64(%rip), %rsi       # 0x5246
callq 0x21c0
movq %rax, %rdi
movq 0x38cf(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq 0x38d3(%rip), %rdi      # 0x7fd0
leaq 0xb5c(%rip), %rsi       # 0x5260
callq 0x21c0
movq %rax, %rdi
movq 0x38ad(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq 0x38b1(%rip), %rdi      # 0x7fd0
leaq 0xb49(%rip), %rsi       # 0x526f
callq 0x21c0
movq %rax, %rdi
movq 0x388b(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq %rax, %rdi
movq 0x387c(%rip), %rsi      # 0x7fc0
callq 0x21f0
movq 0x3880(%rip), %rdi      # 0x7fd0
leaq 0xb22(%rip), %rsi       # 0x5279
callq 0x21c0
movq -0x10(%rbp), %rsi
movq 0x3879(%rip), %rdi      # 0x7fe0
callq 0x20f0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4777
jmp 0x47c2
jmp 0x4779
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, (%rcx)
movb %al, -0x11(%rbp)
jl 0x4794
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
setg %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x479d
jmp 0x47c2
movq 0x382c(%rip), %rdi      # 0x7fd0
leaq 0xace(%rip), %rsi       # 0x5279
callq 0x21c0
movq -0x10(%rbp), %rsi
movq 0x3825(%rip), %rdi      # 0x7fe0
callq 0x20f0
jmp 0x4779
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AlanReviews[P]Goblet-of-fire/main.cc
// Function: main
int main() {
    // Create a control object called c
    Control c;
    // Launch the control object
    c.launch();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2500
movq -0x38(%rbp), %rdi
callq 0x2600
jmp 0x47f7
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2520
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2520
movq -0x28(%rbp), %rdi
callq 0x22c0
// File: 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:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x288(%rsp)
movq %rsi, 0x280(%rsp)
movq 0x288(%rsp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
movl $0x4, %edx
callq 0x2330
movq 0x78(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x78(%rsp,%rax), %rdi
callq 0x2230
movb %al, 0x23(%rsp)
jmp 0x26ef
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x26fc
jmp 0x2813
movq 0x78(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x78(%rsp,%rax), %rdi
callq 0x4930
jmp 0x2711
xorl %eax, %eax
movl %eax, %esi
leaq 0x78(%rsp), %rdi
movl $0x2, %edx
callq 0x2250
jmp 0x2726
leaq 0x78(%rsp), %rdi
callq 0x22f0
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x273c
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4950
movq %rax, 0x8(%rsp)
jmp 0x2761
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x78(%rsp), %rdi
callq 0x2250
jmp 0x277b
movq 0x280(%rsp), %rdi
movq 0x60(%rsp), %rsi
movb $0x0, 0x4f(%rsp)
leaq 0x4f(%rsp), %rdx
callq 0x4960
jmp 0x2799
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x4a90
jmp 0x27aa
leaq 0x28(%rsp), %rdi
callq 0x4ac0
jmp 0x27b6
movq 0x280(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4ae0
movq %rax, %rdx
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4a20
jmp 0x27db
leaq 0x78(%rsp), %rdi
callq 0x2050
jmp 0x27e7
movb $0x1, 0x297(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x2823
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2070
jmp 0x283e
movb $0x0, 0x297(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2070
movb 0x297(%rsp), %al
andb $0x1, %al
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x70(%rsp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq 0x228(%rsp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x21f0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
callq 0x4930
jmp 0x289b
movq 0x230(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4b00
movq %rax, 0x10(%rsp)
movq 0x230(%rsp), %rdi
callq 0x4b20
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x28(%rsp), %rdi
callq 0x2240
jmp 0x28d2
leaq 0x28(%rsp), %rdi
callq 0x2280
jmp 0x28de
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
callq 0x2230
movb %al, 0xf(%rsp)
jmp 0x28f7
movb 0xf(%rsp), %al
andb $0x1, %al
negb %al
movb %al, 0xe(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22a0
movb 0xe(%rsp), %al
andb $0x1, %al
addq $0x238, %rsp            # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22a0
movq 0x20(%rsp), %rdi
callq 0x2310
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2100
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4b20
subq $0x1, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
ja 0x29a3
movq 0x28(%rsp), %rdi
callq 0x4b20
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x29af
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%rsp)
jmp 0x29af
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2a34
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x4ae0
movzbl (%rax), %eax
movzbl 0x27(%rsp), %ecx
shll %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4ae0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movzbl (%rcx), %edx
movzbl 0x27(%rsp), %esi
movl $0x8, %ecx
subl %esi, %ecx
sarl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movb %al, 0x26(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x26(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x296d
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x2a96
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cvtsi2sd %rax, %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x2a5c
movsd -0x18(%rsp), %xmm0
movaps 0x1556d(%rip), %xmm2    # 0x18010
movq -0x10(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1556b(%rip), %xmm2    # 0x18020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2a40
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2b4d
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %eax
cvtsi2sd %rax, %xmm0
subsd 0x10(%rsp), %xmm0
movsd 0x1550a(%rip), %xmm1    # 0x18038
callq 0x2300
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2b04
movsd 0x8(%rsp), %xmm0
movaps 0x154b6(%rip), %xmm2    # 0x18010
movq 0x18(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x154b4(%rip), %xmm2    # 0x18020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
movsd 0x154ad(%rip), %xmm2    # 0x18030
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2140
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)