LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: simap[P]ecctools/lib/uECC.c
// Function: vli_numDigits(unsigned long const*, signed char)
static wordcount_t vli_numDigits(const uECC_word_t *vli, const wordcount_t max_words) {
    wordcount_t i;
    /* Search from the end until we find a non-zero digit.
       We do it in reverse because we expect that most digits will be nonzero. */
    for (i = max_words - 1; i >= 0 && vli[i] == 0; --i) {
    }

    return (i + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
subl $0x1, %eax
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
jl 0x660a
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0x6613
jmp 0x661f
jmp 0x6615
movb -0xa(%rbp), %al
addb $-0x1, %al
movb %al, -0xa(%rbp)
jmp 0x65e8
movsbl -0xa(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: simap[P]ecctools/lib/SHA256.cpp
// Function: SHA256::reset()
void SHA256::reset()
{
    state.h[0] = 0x6a09e667;
    state.h[1] = 0xbb67ae85;
    state.h[2] = 0x3c6ef372;
    state.h[3] = 0xa54ff53a,
    state.h[4] = 0x510e527f;
    state.h[5] = 0x9b05688c;
    state.h[6] = 0x1f83d9ab;
    state.h[7] = 0x5be0cd19;
    state.chunkSize = 0;
    state.length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6a09e667, 0x8(%rax)  # imm = 0x6A09E667
movl $0xbb67ae85, 0xc(%rax)  # imm = 0xBB67AE85
movl $0x3c6ef372, 0x10(%rax) # imm = 0x3C6EF372
movl $0xa54ff53a, 0x14(%rax) # imm = 0xA54FF53A
movl $0x510e527f, 0x18(%rax) # imm = 0x510E527F
movl $0x9b05688c, 0x1c(%rax) # imm = 0x9B05688C
movl $0x1f83d9ab, 0x20(%rax) # imm = 0x1F83D9AB
movl $0x5be0cd19, 0x24(%rax) # imm = 0x5BE0CD19
movb $0x0, 0x70(%rax)
movq $0x0, 0x68(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: simap[P]ecctools/lib/SHA256.cpp
// Function: SHA256::update(void const*, unsigned long)
void SHA256::update(const void *data, size_t len)
{
    // Update the total length (in bits, not bytes).
    state.length += ((uint64_t)len) << 3;

    // Break the input up into 512-bit chunks and process each in turn.
    const uint8_t *d = (const uint8_t *)data;
    while (len > 0) {
        uint8_t size = 64 - state.chunkSize;
        if (size > len)
            size = len;
        memcpy(((uint8_t *)state.w) + state.chunkSize, d, size);
        state.chunkSize += size;
        len -= size;
        d += size;
        if (state.chunkSize == 64) {
            processChunk();
            state.chunkSize = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x682c
movq -0x30(%rbp), %rax
movzbl 0x70(%rax), %ecx
movl $0x40, %eax
subl %ecx, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpq -0x18(%rbp), %rax
jbe 0x67b2
movq -0x18(%rbp), %rax
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
addq $0x20, %rdi
movzbl 0x70(%rax), %eax
cltq
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movzbl -0x21(%rbp), %eax
movl %eax, %edx
callq 0x10b0
movq -0x30(%rbp), %rax
movzbl -0x21(%rbp), %edx
movzbl 0x70(%rax), %ecx
addl %edx, %ecx
movb %cl, 0x70(%rax)
movzbl -0x21(%rbp), %ecx
movl %ecx, %edx
movq -0x18(%rbp), %rcx
subq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movzbl -0x21(%rbp), %edx
movq -0x20(%rbp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movzbl 0x70(%rax), %eax
cmpl $0x40, %eax
jne 0x6827
movq -0x30(%rbp), %rdi
callq 0x6840
movq -0x30(%rbp), %rax
movb $0x0, 0x70(%rax)
jmp 0x6784
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: simap[P]ecctools/lib/SHA256.cpp
// Function: clean(void*, unsigned long)
static void clean(void *dest, size_t size)
{
    // Force the use of volatile so that we actually clear the memory.
    // Otherwise the compiler might optimise the entire contents of this
    // function away, which will not be secure.
    volatile uint8_t *d = (volatile uint8_t *)dest;
    while (size > 0) {
        *d++ = 0;
        --size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x705b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7034
popq %rbp
retq
nopl (%rax)
// File: pstuifzand[P]magento-tools/src/block-lister.cpp
// Function: parse_xml(xml_parser&, std::basic_ifstream<char, std::char_traits<char>>&, user_data*)
void parse_xml(xml_parser& parser, std::ifstream& in, user_data* data) {
    const int size = 1024;
    char buf[size];
    while (in) {
        in.read(buf, size);
        XML_Status ret = XML_Parse(parser.handle(), buf, in.gcount(), in ? 0 : 1);
        if (!ret) {
            XML_Error error = XML_GetErrorCode(parser.handle());
            int line = XML_GetCurrentLineNumber(parser.handle());
            std::cerr << data->filename << ":" << line << ": error: " << XML_ErrorString(error) << "\n";
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x400, -0x1c(%rbp)     # imm = 0x400
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1110
testb $0x1, %al
jne 0x16e7
jmp 0x181a
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1120
movq -0x8(%rbp), %rdi
callq 0x1a90
movq %rax, -0x440(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d0
movl %eax, -0x430(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1110
movq -0x440(%rbp), %rdi
movq -0x438(%rbp), %rsi
movl -0x430(%rbp), %edx
movb %al, %r8b
movl $0x1, %ecx
xorl %eax, %eax
testb $0x1, %r8b
cmovnel %eax, %ecx
callq 0x11b0
movl %eax, -0x424(%rbp)
cmpl $0x0, -0x424(%rbp)
jne 0x1815
movq -0x8(%rbp), %rdi
callq 0x1a90
movq %rax, %rdi
callq 0x1130
movl %eax, -0x428(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a90
movq %rax, %rdi
callq 0x1090
movl %eax, -0x42c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq 0x283e(%rip), %rdi      # 0x3ff0
callq 0x10e0
movq %rax, %rdi
leaq 0x89a(%rip), %rsi       # 0x205b
callq 0x10e0
movq %rax, %rdi
movl -0x42c(%rbp), %esi
callq 0x1180
movq %rax, %rdi
leaq 0x87f(%rip), %rsi       # 0x205d
callq 0x10e0
movq %rax, -0x448(%rbp)
movl -0x428(%rbp), %edi
callq 0x1030
movq -0x448(%rbp), %rdi
movq %rax, %rsi
callq 0x10e0
movq %rax, %rdi
leaq 0x831(%rip), %rsi       # 0x203f
callq 0x10e0
jmp 0x181a
jmp 0x16ce
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/block-lister.cpp
// Function: main
int main(int argc, char** argv)
{
    // remove program name
    argc--;
    argv++;

    // no arguments
    if (!argc) return 0;

    // create parser
    xml_parser parser;

    while (argc) {
        user_data data;
        data.in_action = 0;
        data.filename = *argv;

        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        std::ifstream in{data.filename};
        if (in) parse_xml(parser, in, &data);
        parser.reset();

        argc--;
        argv++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1870
movl $0x0, -0x4(%rbp)
jmp 0x19cb
leaq -0x18(%rbp), %rdi
callq 0x1ab0
cmpl $0x0, -0x8(%rbp)
je 0x19c2
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1a90
movq %rax, -0x248(%rbp)
jmp 0x18a7
movq -0x248(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1040
jmp 0x18b9
leaq -0x18(%rbp), %rdi
callq 0x1a90
movq %rax, -0x250(%rbp)
jmp 0x18cb
movq -0x250(%rbp), %rdi
leaq -0x5b9(%rip), %rsi      # 0x1320
leaq -0x290(%rip), %rdx      # 0x1650
callq 0x10d0
jmp 0x18e7
leaq -0x18(%rbp), %rdi
callq 0x1a90
movq %rax, -0x258(%rbp)
jmp 0x18f9
movq -0x258(%rbp), %rdi
leaq -0x277(%rip), %rsi      # 0x1690
callq 0x1100
jmp 0x190e
movq -0x28(%rbp), %rsi
leaq -0x240(%rbp), %rdi
movl $0x8, %edx
callq 0x11c0
jmp 0x1925
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x240(%rbp,%rax), %rdi
callq 0x1110
movb %al, -0x259(%rbp)
jmp 0x1945
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x1951
jmp 0x1991
leaq -0x18(%rbp), %rdi
leaq -0x240(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x16b0
jmp 0x1967
jmp 0x1991
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x19d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x1050
jmp 0x19d7
leaq -0x18(%rbp), %rdi
callq 0x1ae0
jmp 0x199c
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x1050
jmp 0x1879
leaq -0x18(%rbp), %rdi
callq 0x1b10
movl -0x4(%rbp), %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x1b10
movq -0x30(%rbp), %rdi
callq 0x11a0
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::FragTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FragTrap::FragTrap(std::string name)
{
	this->hitPoints = 100;
	this->maxHit = 100;
	this->energyPoints = 100;
	this->maxEnergyPoints = 100;
	this->name = name;
	this->meleeAttackDamage = 30;
	this->rangedAttackDamage = 20;
	this->armorDamageReduction = 5;
	this->level = 1.0;
	std::cout << this->name << ": Hi ! I'm ready !" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x21b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x64, (%rax)
movl $0x64, 0x4(%rax)
movl $0x64, 0x8(%rax)
movl $0x64, 0xc(%rax)
callq 0x2030
jmp 0x2457
movq -0x38(%rbp), %rsi
movl $0x1e, 0x38(%rsi)
movl $0x14, 0x3c(%rsi)
movl $0x5, 0x40(%rsi)
movl $0x3f800000, 0x10(%rsi) # imm = 0x3F800000
addq $0x18, %rsi
movq 0x3b56(%rip), %rdi      # 0x5fd8
callq 0x20f0
movq %rax, -0x40(%rbp)
jmp 0x248d
movq -0x40(%rbp), %rdi
leaq 0x1b80(%rip), %rsi      # 0x4018
callq 0x2120
movq %rax, -0x48(%rbp)
jmp 0x24a3
movq -0x48(%rbp), %rdi
movq 0x3b1a(%rip), %rsi      # 0x5fc8
callq 0x2130
jmp 0x24b5
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2090
movq -0x18(%rbp), %rdi
callq 0x2200
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::operator=(FragTrap const&)
FragTrap	&FragTrap::operator=(FragTrap const &other)
{
	this->hitPoints = other.hitPoints;
	this->maxHit = other.maxHit;
	this->energyPoints = other.energyPoints;
	this->maxEnergyPoints = other.maxEnergyPoints;
	this->name = other.name;
	this->meleeAttackDamage = other.meleeAttackDamage;
	this->rangedAttackDamage = other.rangedAttackDamage;
	this->armorDamageReduction = other.armorDamageReduction;
	this->level = other.level;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movl 0x3c(%rcx), %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movss 0x10(%rcx), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::takeDamage(unsigned int)
void		FragTrap::takeDamage(unsigned int damage)
{
	damage -= this->armorDamageReduction;
	damage = (damage < 0 ? 0 : damage);
	this->hitPoints -= damage;
	this->hitPoints = (this->hitPoints < 0 ? 0 : this->hitPoints);
	std::cout << this->name << " took " << damage << " damages.";
	std::cout << " He has now " << this->hitPoints << " hit points." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x40(%rax), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jae 0x27cf
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27d5
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %edx
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jge 0x27f4
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x27fd
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, (%rsi)
addq $0x18, %rsi
movq 0x37c7(%rip), %rdi      # 0x5fd8
callq 0x20f0
movq %rax, %rdi
leaq 0x1860(%rip), %rsi      # 0x4080
callq 0x2120
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2190
movq %rax, %rdi
leaq 0x1825(%rip), %rsi      # 0x405f
callq 0x2120
movq 0x3792(%rip), %rdi      # 0x5fd8
leaq 0x183a(%rip), %rsi      # 0x4087
callq 0x2120
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x182a(%rip), %rsi      # 0x4094
callq 0x2120
movq %rax, %rdi
movq 0x374f(%rip), %rsi      # 0x5fc8
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex01/ScavTrap.cpp
// Function: ScavTrap::ScavTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ScavTrap::ScavTrap(std::string name)
{
	this->hitPoints = 100;
	this->maxHit = 100;
	this->energyPoints = 50;
	this->maxEnergyPoints = 50;
	this->name = name;
	this->meleeAttackDamage = 20;
	this->rangedAttackDamage = 15;
	this->armorDamageReduction = 3;
	this->level = 1.0;
	std::cout << this->name << ": Hey ! At your service." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x21b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x64, (%rax)
movl $0x64, 0x4(%rax)
movl $0x32, 0x8(%rax)
movl $0x32, 0xc(%rax)
callq 0x2030
jmp 0x2bc7
movq -0x38(%rbp), %rsi
movl $0x14, 0x38(%rsi)
movl $0xf, 0x3c(%rsi)
movl $0x3, 0x40(%rsi)
movl $0x3f800000, 0x10(%rsi) # imm = 0x3F800000
addq $0x18, %rsi
movq 0x33e6(%rip), %rdi      # 0x5fd8
callq 0x20f0
movq %rax, -0x40(%rbp)
jmp 0x2bfd
movq -0x40(%rbp), %rdi
leaq 0x1554(%rip), %rsi      # 0x415c
callq 0x2120
movq %rax, -0x48(%rbp)
jmp 0x2c13
movq -0x48(%rbp), %rdi
movq 0x33aa(%rip), %rsi      # 0x5fc8
callq 0x2130
jmp 0x2c25
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2090
movq -0x18(%rbp), %rdi
callq 0x2200
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex01/ScavTrap.cpp
// Function: ScavTrap::challengeNewcomer()
void		ScavTrap::challengeNewcomer(void)
{
	int			choice;
	std::string	challenge;

	choice = rand() % 5;
	switch (choice) {
		case 0:
			challenge = "jump off the 20th floor";
			break;
		case 1:
			challenge = "do a backflip";
			break;
		case 2:
			challenge = "eat an spider";
			break;
		case 3:
			challenge = "walk 5 meters on your hands";
			break;
		case 4:
			challenge = "make me a coffee";
			break;
	}
	std::cout << this->name << ": I have a challenge for you: " << challenge << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21b0
callq 0x2050
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x48(%rbp)
subq $0x4, %rax
ja 0x3186
movq -0x48(%rbp), %rax
leaq 0x1049(%rip), %rcx      # 0x4148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10b8(%rip), %rsi      # 0x41c7
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x311a
jmp 0x3186
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2090
jmp 0x31ea
leaq 0x10a2(%rip), %rsi      # 0x41df
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x3148
jmp 0x3186
leaq 0x109c(%rip), %rsi      # 0x41ed
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x315c
jmp 0x3186
leaq 0x1096(%rip), %rsi      # 0x41fb
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x3170
jmp 0x3186
leaq 0x109e(%rip), %rsi      # 0x4217
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x3184
jmp 0x3186
movq -0x50(%rbp), %rsi
addq $0x18, %rsi
movq 0x2e43(%rip), %rdi      # 0x5fd8
callq 0x20f0
movq %rax, -0x58(%rbp)
jmp 0x31a0
movq -0x58(%rbp), %rdi
leaq 0x107d(%rip), %rsi      # 0x4228
callq 0x2120
movq %rax, -0x60(%rbp)
jmp 0x31b6
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
movq %rax, -0x68(%rbp)
jmp 0x31c9
movq -0x68(%rbp), %rdi
movq 0x2df4(%rip), %rsi      # 0x5fc8
callq 0x2130
jmp 0x31db
leaq -0x30(%rbp), %rdi
callq 0x2090
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ammarfaizi2[P]TeaCurlCpp/TeaCurl.cpp
// Function: TeaCurl::setUp()
void TeaCurl::setUp() {
	curl_easy_setopt(this->ch, CURLOPT_URL, this->url.c_str());
	curl_easy_setopt(this->ch, CURLOPT_SSL_VERIFYPEER, 0);
	curl_easy_setopt(this->ch, CURLOPT_SSL_VERIFYHOST, 0);
	curl_easy_setopt(this->ch, CURLOPT_FOLLOWLOCATION, 1);
	
	curl_easy_setopt(this->ch, CURLOPT_WRITEFUNCTION, TeaCurl::__teaCurlWriteFunc);	
	curl_easy_setopt(this->ch, CURLOPT_WRITEDATA, &this->out);

	curl_easy_setopt(this->ch, CURLOPT_HEADERFUNCTION, TeaCurl::__teaCurlWriteFunc);
	curl_easy_setopt(this->ch, CURLOPT_WRITEHEADER, &this->responseHeader);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rdi
callq 0x2090
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movl $0x2712, %esi           # imm = 0x2712
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x40, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x51, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x34, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
leaq -0x19c(%rip), %rdx      # 0x2c20
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rdx
movq (%rdx), %rdi
addq $0x20, %rdx
movl $0x2711, %esi           # imm = 0x2711
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x4e6f, %esi           # imm = 0x4E6F
leaq -0x1cd(%rip), %rdx      # 0x2c20
movb $0x0, %al
callq 0x21c0
movq -0x10(%rbp), %rdx
movq (%rdx), %rdi
addq $0x80, %rdx
movl $0x272d, %esi           # imm = 0x272D
movb $0x0, %al
callq 0x21c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ammarfaizi2[P]TeaCurlCpp/TeaCurl.cpp
// Function: TeaCurl::exec()
void TeaCurl::exec() {
	this->res = curl_easy_perform(ch);
	if(this->res == CURLE_OK) {
		curl_easy_getinfo(this->ch, CURLINFO_RESPONSE_CODE, &this->httpCode);
	} else {
		this->error = curl_easy_strerror(this->res);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x2160
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x2e84
movq -0x10(%rbp), %rdx
movq (%rdx), %rdi
addq $0x10, %rdx
movl $0x200002, %esi         # imm = 0x200002
movb $0x0, %al
callq 0x2220
jmp 0x2ea0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2140
movq -0x10(%rbp), %rdi
movq %rax, %rsi
addq $0x60, %rdi
callq 0x2110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/sexpr/types.cpp
// Function: sexpr::sexpr_conslist::islist()
bool sexpr::sexpr_conslist::islist() {
    auto walk = cdr;
    while (walk->iscons())
        walk = walk->cdr();
    return walk->isnil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
callq 0x43d0
leaq -0x18(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x72b0
movb %al, -0x39(%rbp)
jmp 0x3b33
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3b3c
jmp 0x3b82
leaq -0x18(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xb440
jmp 0x3b53
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4420
leaq -0x38(%rbp), %rdi
callq 0x4450
jmp 0x3b1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4450
jmp 0x3bac
leaq -0x18(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
movb %al, -0x3a(%rbp)
jmp 0x3b98
leaq -0x18(%rbp), %rdi
callq 0x4450
movb -0x3a(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/sexpr/types.cpp
// Function: sexpr::sexpr_lambda::require_evaled_args()
bool sexpr::sexpr_lambda::require_evaled_args() {
    return not (native == builtin::_quote
                or native == builtin::_quasiquote
                or native == builtin::_define
                or native == builtin::_set
                or native == builtin::_unset
                or native == builtin::_cons_car_flavor
                or native == builtin::_cons_cdr_flavor
                or native == builtin::_if
                or native == builtin::_cond
                or native == builtin::_let
                or native == builtin::_let_astrk
                or native == builtin::_let_rec
                or native == builtin::_do);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
leaq 0x8ad7(%rip), %rdx      # 0xcb40
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0x8c8d(%rip), %rdx      # 0xcd10
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0x8403(%rip), %rdx      # 0xc4a0
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0x9b39(%rip), %rdx      # 0xdbf0
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0x9e9f(%rip), %rdx      # 0xdf70
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xf595(%rip), %rdx      # 0x13680
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xf9ab(%rip), %rdx      # 0x13ab0
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xa2a1(%rip), %rdx      # 0xe3c0
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xa7eb(%rip), %rdx      # 0xe920
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xad35(%rip), %rdx      # 0xee80
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xba5f(%rip), %rdx      # 0xfbc0
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rcx
movb $0x1, %al
leaq 0xc0a9(%rip), %rdx      # 0x10220
cmpq %rdx, 0x58(%rcx)
movb %al, -0x9(%rbp)
je 0x4195
movq -0x18(%rbp), %rax
leaq 0xc915(%rip), %rcx      # 0x10aa0
cmpq %rcx, 0x58(%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 0x0584[P]scmin-plus/src/sexpr/sexpr.cpp
// Function: sexpr::length()
size_t sexpr::length() {
    size_t sz = 1;
    sexpr_t walk;

    if (isatom() or ispair())
        return 0;
    walk = cdr();
    while (not walk->isnil())
        sz++, walk = walk->cdr();
    return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x1, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ef0
movq -0x68(%rbp), %rdi
callq 0x73d0
movb %al, -0x59(%rbp)
jmp 0x7603
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x7623
jmp 0x760c
movq -0x68(%rbp), %rdi
callq 0x7360
movb %al, -0x69(%rbp)
jmp 0x761a
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x7623
jmp 0x7651
movq $0x0, -0x8(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x76d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x76eb
movq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xb440
jmp 0x7660
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4420
leaq -0x48(%rbp), %rdi
callq 0x4450
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x7270
xorb $-0x1, %al
testb $0x1, %al
jne 0x768f
jmp 0x76c9
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xb440
jmp 0x76b1
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4420
leaq -0x58(%rbp), %rdi
callq 0x4450
jmp 0x7676
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4450
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
nop
// File: 0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: cons_append(std::shared_ptr<sexpr> const&, std::shared_ptr<sexpr>&, std::shared_ptr<sexpr>&)
bool cons_append(const sexpr_t& e, sexpr_t& expr, sexpr_t& tail) {
    if (e == nullptr)
        return false;
    if (not expr)
        tail = expr = cons(e, nil());
    else {
        tail->setcdr(cons(e, nil()));
        tail = tail->cdr();
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb590
testb $0x1, %al
jne 0xb25a
jmp 0xb263
movb $0x0, -0x1(%rbp)
jmp 0xb3b5
movq -0x18(%rbp), %rdi
callq 0xb5c0
testb $0x1, %al
jne 0xb2ee
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x78f0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7a40
jmp 0xb2a4
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4420
movq %rax, %rsi
movq -0x20(%rbp), %rdi
callq 0xb5e0
leaq -0x30(%rbp), %rdi
callq 0x4450
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0xb3b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0xb3c3
movq -0x20(%rbp), %rdi
callq 0x4400
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x78f0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x7a40
jmp 0xb332
movq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xb3d0
jmp 0xb344
leaq -0x60(%rbp), %rdi
callq 0x4450
leaq -0x70(%rbp), %rdi
callq 0x4450
movq -0x20(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xb440
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4420
leaq -0x80(%rbp), %rdi
callq 0x4450
jmp 0xb3b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb3a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4450
leaq -0x70(%rbp), %rdi
callq 0x4450
jmp 0xb3c3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcdr(std::shared_ptr<sexpr> const&)
bool sexpr::setcdr(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->cdr = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7360
testb $0x1, %al
jne 0xb404
movq -0x20(%rbp), %rdi
callq 0x72f0
testb $0x1, %al
jne 0xb404
movb $0x0, -0x1(%rbp)
jmp 0xb431
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4520
movq %rax, %rdi
callq 0x7720
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rdi
callq 0xb5e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcar(std::shared_ptr<sexpr> const&)
bool sexpr::setcar(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->car = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7360
testb $0x1, %al
jne 0xb4e4
movq -0x20(%rbp), %rdi
callq 0x72f0
testb $0x1, %al
jne 0xb4e4
movb $0x0, -0x1(%rbp)
jmp 0xb50d
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4520
movq %rax, %rdi
callq 0x7720
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0xb5e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_ispair(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_ispair(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->ispair() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xb73d
movq 0x228e0(%rip), %rdi     # 0x2dff0
leaq 0x15b19(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x2286a(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xb852
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7360
movb %al, -0x71(%rbp)
jmp 0xb774
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xb77d
jmp 0xb7bf
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x1605a(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xb7aa
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xb7bd
jmp 0xb7cc
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xb7ca
jmp 0xb7cc
testb $0x1, -0x5b(%rbp)
jne 0xb7d4
jmp 0xb7dd
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xb7e5
jmp 0xb7ee
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xb852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb834
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xb829
jmp 0xb832
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xb834
testb $0x1, -0x5a(%rbp)
jne 0xb83c
jmp 0xb845
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xb847
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xb85f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_islist(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_islist(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->islist() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xb8dd
movq 0x22740(%rip), %rdi     # 0x2dff0
leaq 0x15979(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x226ca(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xb9f2
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x72f0
movb %al, -0x71(%rbp)
jmp 0xb914
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xb91d
jmp 0xb95f
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x15eba(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xb94a
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xb95d
jmp 0xb96c
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xb96a
jmp 0xb96c
testb $0x1, -0x5b(%rbp)
jne 0xb974
jmp 0xb97d
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xb985
jmp 0xb98e
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xb9f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb9e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb9d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xb9c9
jmp 0xb9d2
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xb9d4
testb $0x1, -0x5a(%rbp)
jne 0xb9dc
jmp 0xb9e5
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xb9e7
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xb9ff
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isnum(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_isnum(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isnum() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xba7d
movq 0x225a0(%rip), %rdi     # 0x2dff0
leaq 0x157d9(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x2252a(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xbb92
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7430
movb %al, -0x71(%rbp)
jmp 0xbab4
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbabd
jmp 0xbaff
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x15d1a(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xbaea
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xbafd
jmp 0xbb0c
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xbb0a
jmp 0xbb0c
testb $0x1, -0x5b(%rbp)
jne 0xbb14
jmp 0xbb1d
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xbb25
jmp 0xbb2e
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbb92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbb87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbb74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xbb69
jmp 0xbb72
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xbb74
testb $0x1, -0x5a(%rbp)
jne 0xbb7c
jmp 0xbb85
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xbb87
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbb9f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isnil(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_isnil(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isnil() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xbc1d
movq 0x22400(%rip), %rdi     # 0x2dff0
leaq 0x15639(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x2238a(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xbd32
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7270
movb %al, -0x71(%rbp)
jmp 0xbc54
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbc5d
jmp 0xbc9f
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x15b7a(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xbc8a
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xbc9d
jmp 0xbcac
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xbcaa
jmp 0xbcac
testb $0x1, -0x5b(%rbp)
jne 0xbcb4
jmp 0xbcbd
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xbcc5
jmp 0xbcce
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbd32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbd27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbd14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xbd09
jmp 0xbd12
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xbd14
testb $0x1, -0x5a(%rbp)
jne 0xbd1c
jmp 0xbd25
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xbd27
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbd3f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_isstr(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_isstr(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->isstr() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xbdbd
movq 0x22260(%rip), %rdi     # 0x2dff0
leaq 0x15499(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x221ea(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xbed2
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7470
movb %al, -0x71(%rbp)
jmp 0xbdf4
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbdfd
jmp 0xbe3f
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x159da(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xbe2a
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xbe3d
jmp 0xbe4c
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xbe4a
jmp 0xbe4c
testb $0x1, -0x5b(%rbp)
jne 0xbe54
jmp 0xbe5d
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xbe65
jmp 0xbe6e
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbed2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbeb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xbea9
jmp 0xbeb2
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xbeb4
testb $0x1, -0x5a(%rbp)
jne 0xbebc
jmp 0xbec5
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xbec7
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xbedf
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/builtin/types.cpp
// Function: builtin::_issymb(std::shared_ptr<sexpr> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<sexpr>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::shared_ptr<sexpr>>>>&)
sexpr_t builtin::_issymb(const sexpr_t& args, env_t& bindings) {
    (void)bindings;
    if (args->length() != 1) {
        cerr << "Err: expect one argument" << endl;
        return nullptr;
    }
    return args->car()->issymb() ? symb("t") : nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
callq 0x75d0
cmpq $0x1, %rax
je 0xbf5d
movq 0x220c0(%rip), %rdi     # 0x2dff0
leaq 0x152f9(%rip), %rsi     # 0x21230
callq 0x32c0
movq %rax, %rdi
movq 0x2204a(%rip), %rsi     # 0x2df90
callq 0x32f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4570
jmp 0xc072
movq -0x10(%rbp), %rdi
callq 0x4400
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb520
movq -0x80(%rbp), %rdi
callq 0x4400
movq %rax, %rdi
movb $0x0, -0x5a(%rbp)
movb $0x0, -0x5b(%rbp)
callq 0x7500
movb %al, -0x71(%rbp)
jmp 0xbf94
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbf9d
jmp 0xbfdf
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3500
movq -0x88(%rbp), %rdx
movb $0x1, -0x5a(%rbp)
leaq 0x1583a(%rip), %rsi     # 0x217f9
leaq -0x58(%rbp), %rdi
callq 0xc230
jmp 0xbfca
movq -0x70(%rbp), %rdi
movb $0x1, -0x5b(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x7920
jmp 0xbfdd
jmp 0xbfec
movq -0x70(%rbp), %rdi
callq 0x78f0
jmp 0xbfea
jmp 0xbfec
testb $0x1, -0x5b(%rbp)
jne 0xbff4
jmp 0xbffd
leaq -0x58(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x5a(%rbp)
jne 0xc005
jmp 0xc00e
leaq -0x59(%rbp), %rdi
callq 0x3310
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xc072
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc067
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc054
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x5b(%rbp)
jne 0xc049
jmp 0xc052
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0xc054
testb $0x1, -0x5a(%rbp)
jne 0xc05c
jmp 0xc065
leaq -0x59(%rbp), %rdi
callq 0x3310
jmp 0xc067
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0xc07f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)