LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamjanovsky[P]PA193_test_parser_monero/src/block.cpp
// Function: Block::get_miner_tx_hash(std::array<unsigned char, 32ul>&) const
int Block::get_miner_tx_hash(hash::hash_t & miner_tx_hash) const {
    switch (this->miner_tx_version) {
        case 1:
            tools::hash(miner_tx_data.data(), miner_tx_data.size(), &miner_tx_hash[0]);
            return OK;
        case 2: {
            unsigned char to_hash[3 * hash::HASH_SIZE];
            
            // to_hash[0]
            tools::hash(miner_tx_data.data(), miner_tx_data.size(), to_hash);
            
            // to_hash[1]
            unsigned char zero_byte[1] = {0x00};
            tools::hash(zero_byte, 1, to_hash + hash::HASH_SIZE);
            
            // to_hash[2]
            memset(to_hash + 2 * hash::HASH_SIZE, 0, hash::HASH_SIZE);
            
            tools::hash(to_hash, 3 * hash::HASH_SIZE, &miner_tx_hash[0]);
            return OK;
        }
        default:
            return ERR_BL_HASH_TRANS_WRONG_VERSION;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x78(%rax), %eax
movl %eax, -0x88(%rbp)
subl $0x1, %eax
je 0x3efe
jmp 0x3eee
movl -0x88(%rbp), %eax
subl $0x2, %eax
je 0x3f5b
jmp 0x400a
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
callq 0x46d0
movq -0x90(%rbp), %rdi
movq %rax, -0xa0(%rbp)
addq $0x60, %rdi
callq 0x46b0
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f00
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq %rax, %rdx
callq 0x7d30
movl $0x0, -0x4(%rbp)
jmp 0x4011
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
callq 0x46d0
movq -0x90(%rbp), %rdi
movq %rax, -0xb0(%rbp)
addq $0x60, %rdi
callq 0x46b0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
leaq -0x80(%rbp), %rdx
callq 0x7d30
leaq -0x81(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x20f0
leaq -0x81(%rbp), %rdi
leaq -0x80(%rbp), %rdx
addq $0x20, %rdx
movl $0x1, %esi
callq 0x7d30
leaq -0x80(%rbp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x20f0
leaq -0x80(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f00
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
movl $0x60, %esi
callq 0x7d30
movl $0x0, -0x4(%rbp)
jmp 0x4011
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::expect_byte(std::istream&, unsigned char)
int tools::expect_byte(std::istream & in, unsigned char expected_byte) {
    unsigned char c;
    in.read(reinterpret_cast<char *>(&c), 1);
    
    // Check for EOF
    if (!in.good()) {
        std::cerr << "Expect byte: Unexpected end of stream." << std::endl;
        return ERR_EXPBT_UNEXPECTED_EOF;
    }
    
    // Check the value
    if (c != expected_byte) {
        std::cerr << "Expect byte: Input " << std::hex << c;
        std::cerr << std::dec << " does not match expected input ";
        std::cerr << std::hex << expected_byte << std::dec << "." << std::endl;
        return ERR_EXPBT_DOES_NOT_MATCH;
    }
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22a0
testb $0x1, %al
jne 0x77f6
movq 0x5821(%rip), %rdi      # 0xcff0
leaq 0x1d1e(%rip), %rsi      # 0x94f4
callq 0x2160
movq %rax, %rdi
movq 0x57db(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x78b2
movzbl -0x12(%rbp), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x78ab
movq 0x57e3(%rip), %rdi      # 0xcff0
leaq 0x1d07(%rip), %rsi      # 0x951b
callq 0x2160
movq %rax, %rdi
leaq 0x8cd(%rip), %rsi       # 0x80f0
callq 0x2080
movq %rax, %rdi
movzbl -0x12(%rbp), %esi
callq 0x2240
movq 0x57b5(%rip), %rdi      # 0xcff0
leaq 0x8de(%rip), %rsi       # 0x8120
callq 0x2080
movq %rax, %rdi
leaq 0x1cde(%rip), %rsi      # 0x952f
callq 0x2160
movq 0x5793(%rip), %rdi      # 0xcff0
leaq 0x88c(%rip), %rsi       # 0x80f0
callq 0x2080
movq %rax, %rdi
movzbl -0x11(%rbp), %esi
callq 0x2240
movq %rax, %rdi
leaq 0x8a1(%rip), %rsi       # 0x8120
callq 0x2080
movq %rax, %rdi
leaq 0x1839(%rip), %rsi      # 0x90c7
callq 0x2160
movq %rax, %rdi
movq 0x5723(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78b2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::expect_byte_2(std::istream&, unsigned char)
int tools::expect_byte_2(std::istream & in, unsigned char expected_byte) {
    unsigned char c;
    in.read(reinterpret_cast<char *>(&c), 1);
    
    // Check for EOF
    if (!in.good()) {
        std::cerr << "Expect byte: Unexpected end of stream." << std::endl;
        return ERR_EXPBT_UNEXPECTED_EOF;
    }
    
    // Check the value
    if (c != expected_byte) {
        return ERR_EXPBT_DOES_NOT_MATCH;
    }
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22a0
testb $0x1, %al
jne 0x7923
movq 0x56f1(%rip), %rdi      # 0xcff0
leaq 0x1bee(%rip), %rsi      # 0x94f4
callq 0x2160
movq %rax, %rdi
movq 0x56ab(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x793f
movzbl -0x12(%rbp), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x7938
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x793f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::write_varint(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)
int tools::write_varint(std::vector<unsigned char> & out_vect, unsigned long val) {
    
    unsigned char c;
    
    while (val >= 0x80) {
        // get lowest 7 bits
        c = val & 0x7f;
        // save to the vector with the first bit set to 1
        out_vect.push_back(c | 0x80);
        // shift the value
        val >>= 7;
    }
    
    // write the last byte (with the first bit set to 0)
    c = val & 0x7f;
    out_vect.push_back(c);
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x80, -0x10(%rbp)
jb 0x799c
movq -0x10(%rbp), %rax
andq $0x7f, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x11(%rbp), %eax
orl $0x80, %eax
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x8150
movq -0x10(%rbp), %rax
shrq $0x7, %rax
movq %rax, -0x10(%rbp)
jmp 0x7960
movq -0x10(%rbp), %rax
andq $0x7f, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x8180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::skip_varint(std::istream&)
int tools::skip_varint(std::istream & in) {
    unsigned char c;
    in.read((char *)&c, 1);
    int bytes_skipped = 1;

    // read from the stream until there was a byte that started with a zero bit
    while (c & 0x80 && bytes_skipped <= 10) {
        if (in.eof()) {
            std::cerr << "Skip Varint: Unexpected end of stream." << std::endl;
            return ERR_SKIPV_UNEXPECTED_EOF;
        }
        in.read((char *)&c, 1);
        bytes_skipped++;
    }
    
    if (bytes_skipped > 10) {
        std::cerr << "Skip Varint: String too long." << std::endl;
        return ERR_SKIPV_VARINT_TOO_LONG;
    }
    
    return bytes_skipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movl $0x1, -0x18(%rbp)
movzbl -0x11(%rbp), %ecx
andl $0x80, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x7bd3
cmpl $0xa, -0x18(%rbp)
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x7bdc
jmp 0x7c3d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22f0
testb $0x1, %al
jne 0x7bf2
jmp 0x7c1d
movq 0x53f7(%rip), %rdi      # 0xcff0
leaq 0x1994(%rip), %rsi      # 0x9594
callq 0x2160
movq %rax, %rdi
movq 0x53b1(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c74
movq -0x10(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7bb5
cmpl $0xa, -0x18(%rbp)
jle 0x7c6e
movq 0x53a6(%rip), %rdi      # 0xcff0
leaq 0x196a(%rip), %rsi      # 0x95bb
callq 0x2160
movq %rax, %rdi
movq 0x5360(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x7c74
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::skip_bytes(std::istream&, unsigned int)
int tools::skip_bytes(std::istream & in, unsigned int length) {
    if (length == 0) {
        std::cerr << "Skip bytes: Invalid length." << std::endl;
        return ERR_SKIPB_INVALID_LENGTH;
    }
    
    in.seekg(length, std::ios_base::cur);
    if (!in.good()) {
        std::cerr << "Skip bytes: Unexpected end of stream." << std::endl;
        return ERR_SKIPB_UNEXPECTED_EOF;
    }
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x7cc0
movq 0x5354(%rip), %rdi      # 0xcff0
leaq 0x1936(%rip), %rsi      # 0x95d9
callq 0x2160
movq %rax, %rdi
movq 0x530e(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x7d18
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x21f0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22a0
testb $0x1, %al
jne 0x7d12
movq 0x5302(%rip), %rdi      # 0xcff0
leaq 0x1900(%rip), %rsi      # 0x95f5
callq 0x2160
movq %rax, %rdi
movq 0x52bc(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7d18
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::hash(unsigned char const*, unsigned long, unsigned char*)
void tools::hash(const unsigned char *input, size_t input_byte_len, unsigned char *output) {
    // Set the Keccak parameters
    const unsigned int rate                 = 1088;
    const unsigned int capacity             = 512;
    const unsigned char delimited_suffix    = 0x01;
    const size_t output_length              = hash::HASH_SIZE;
    
    // Hash
    Keccak(rate, capacity, input, input_byte_len, delimited_suffix, output, output_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x440, -0x1c(%rbp)     # imm = 0x440
movl $0x200, -0x20(%rbp)     # imm = 0x200
movb $0x1, -0x21(%rbp)
movq $0x20, -0x30(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r9
movl $0x440, %edi            # imm = 0x440
movl $0x200, %esi            # imm = 0x200
movl $0x1, %r8d
movq $0x20, (%rsp)
callq 0x85d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: LFSR86540
int LFSR86540(UINT8 *LFSR)
{
    int result = ((*LFSR) & 0x01) != 0;
    if (((*LFSR) & 0x80) != 0)
    /* Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1 */
        (*LFSR) = ((*LFSR) << 1) ^ 0x71;
    else
        (*LFSR) <<= 1;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8a07
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll %eax
xorl $0x71, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0x8a12
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
shll %ecx
movb %cl, (%rax)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: load64
static UINT64 load64(const UINT8 *x)
{
    int i;
    UINT64 u=0;
    
    for(i=7; i>=0; --i) {
        u <<= 8;
        u |= x[i];
    }
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x7, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x8e78
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8e47
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: xor64
static void xor64(UINT8 *x, UINT64 u)
{
    unsigned int i;
    
    for(i=0; i<8; ++i) {
        x[i] ^= u;
        u >>= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x8ec5
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %edx
xorq %rsi, %rdx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e93
popq %rbp
retq
nopw (%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: store64
static void store64(UINT8 *x, UINT64 u)
{
    unsigned int i;
    
    for(i=0; i<8; ++i) {
        x[i] = u;
        u >>= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x8f10
movq -0x10(%rbp), %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8ee3
popq %rbp
retq
// File: CMU-SAFARI[P]optimal-seed-solver/analyzeBasic.cc
// Function: AnalyzeBasic::storeHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeBasic::storeHash(string tableName) {
	ofstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile << seedLength << endl;

	for (int i = 0; i < freqTable.size(); i++)
		storeFile << freqTable[i] << endl;

	storeFile.close();
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rsi, 0x28(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3510
movq 0x28(%rsp), %rdi
callq 0x3130
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3040
jmp 0x6506
movq 0x20(%rsp), %rax
movl 0x270(%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x33e0
movq %rax, 0x18(%rsp)
jmp 0x6522
movq 0x18(%rsp), %rdi
movq 0x8a8a(%rip), %rsi      # 0xefb8
callq 0x32e0
jmp 0x6535
movl $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x278, %rdi            # imm = 0x278
callq 0x69f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x65ca
movq 0x20(%rsp), %rdi
addq $0x278, %rdi            # imm = 0x278
movslq 0x38(%rsp), %rsi
callq 0x69d0
movl (%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x33e0
movq %rax, 0x8(%rsp)
jmp 0x658e
movq 0x8(%rsp), %rdi
movq 0x8a1e(%rip), %rsi      # 0xefb8
callq 0x32e0
jmp 0x65a1
jmp 0x65a3
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x653d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3450
jmp 0x65e8
leaq 0x48(%rsp), %rdi
callq 0x3430
jmp 0x65d6
leaq 0x48(%rsp), %rdi
callq 0x3450
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x40(%rsp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/analyzeBasic.cc
// Function: AnalyzeBasic::loadHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeBasic::loadHash(string tableName) {
	ifstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile >> seedLength;

	freqTable.resize( (1 << (2 * seedLength) ), 0);
	
	for (int i = 0; i < freqTable.size(); i++)
		storeFile >> freqTable[i];

	storeFile.close();
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rsi, 0x18(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3340
movq 0x18(%rsp), %rdi
callq 0x3130
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x31c0
jmp 0x6656
movq 0x10(%rsp), %rsi
addq $0x270, %rsi            # imm = 0x270
leaq 0x40(%rsp), %rdi
callq 0x3060
jmp 0x666e
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x278, %rdi            # imm = 0x278
movb 0x270(%rax), %cl
addb %cl, %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, %esi
movl $0x0, 0x30(%rsp)
leaq 0x30(%rsp), %rdx
callq 0x6910
jmp 0x66a2
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x278, %rdi            # imm = 0x278
callq 0x69f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x6720
movq 0x10(%rsp), %rdi
addq $0x278, %rdi            # imm = 0x278
movslq 0x2c(%rsp), %rsi
callq 0x69d0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x3060
jmp 0x66f7
jmp 0x66f9
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x66aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30e0
jmp 0x673e
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x672c
leaq 0x40(%rsp), %rdi
callq 0x30e0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x38(%rsp), %rdi
callq 0x3560
nopl (%rax,%rax)
// File: danishansari[P]NumberToText/src/NumToEnglish.cpp
// Function: NumToEnglish::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string NumToEnglish::convert(string numStr)
{
    vector<int> digitsVec;

    // parsing each digits, to convert to int
    for (int i = numStr.length()-1; i >=0 ; i--)
    {
        if ((int)numStr[i] > 47 && (int)numStr[i] < 58)
        {
            // conversion to int
            int tmpNum = (int)numStr[i] - 48;

            // push into the vector 
            digitsVec.push_back(tmpNum);
        }
        else
            return "invalid input";
    }

    // helper function to convert vector of int to text.
    return getText(digitsVec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6700
movq -0x70(%rbp), %rdi
callq 0x22c0
subq $0x1, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x5eeb
movq -0x70(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x23b0
movq %rax, -0x90(%rbp)
jmp 0x5e0a
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jle 0x5e86
movq -0x70(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x23b0
movq %rax, -0x98(%rbp)
jmp 0x5e2f
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jge 0x5e86
movq -0x70(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x23b0
movq %rax, -0xa0(%rbp)
jmp 0x5e54
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
movl %eax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6720
jmp 0x5e73
jmp 0x5edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5f4f
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2360
movq -0x88(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x23c5(%rip), %rsi      # 0x8270
callq 0x4d50
jmp 0x5eb2
leaq -0x49(%rbp), %rdi
callq 0x2240
movl $0x1, -0x50(%rbp)
jmp 0x5f39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x2240
jmp 0x5f4f
jmp 0x5edd
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5dea
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6790
jmp 0x5efa
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x5f70
jmp 0x5f10
leaq -0x68(%rbp), %rdi
callq 0x6880
movl $0x1, -0x50(%rbp)
jmp 0x5f39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6880
jmp 0x5f4f
leaq -0x30(%rbp), %rdi
callq 0x6880
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x6880
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: danishansari[P]NumberToText/src/NumToText.cpp
// Function: NumToText::getConvertor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
NumToText* NumToText::getConvertor(string lang)
{
    // transform input string to lover case
    transform(lang.begin(), lang.end(), lang.begin(), ::tolower);

    // english language
    if (lang == "english")
    {
        // return english lang derived class pointer
        return new NumToEnglish();
    }
    else // other language
        cout << "Err: Language '" << lang << "' not supported." << endl;

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x21a0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x20f0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x21a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x4672(%rip), %rcx      # 0xbfd8
callq 0x7a90
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq 0x719(%rip), %rsi       # 0x8093
callq 0x7b10
testb $0x1, %al
jne 0x7985
jmp 0x79b5
movl $0x8, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x20d0
movq -0x40(%rbp), %rdi
callq 0x7b40
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x79fa
movq 0x4614(%rip), %rdi      # 0xbfd0
leaq 0x8db(%rip), %rsi       # 0x829e
callq 0x21f0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
leaq 0x8d0(%rip), %rsi       # 0x82ae
callq 0x21f0
movq %rax, %rdi
movq 0x45d3(%rip), %rsi      # 0xbfc0
callq 0x2220
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::run()
bool run(){
		running = true;
		char buf[1001];

		while(running && fgets(buf, 1000, in)){
			std::string line(buf);

			trim(line);

			if(line.length() == 0 || line[0] == '#')
				continue;

			GTPResponse response = cmd(line);

			if(out){
				std::string output = response.to_s();

				fwrite(output.c_str(), 1, output.length(), out);
				fflush(out);
			}
		}
		return running;
	}

// Assembly:
subq $0x4e8, %rsp            # imm = 0x4E8
movq %rdi, 0x4e0(%rsp)
movq 0x4e0(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x2c(%rax)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0x2c(%rcx)
movb %al, 0x27(%rsp)
je 0xb6b6
movq 0x28(%rsp), %rax
leaq 0xf0(%rsp), %rdi
movq (%rax), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x56b0
cmpq $0x0, %rax
setne %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xb6c3
jmp 0xb8e6
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5770
movq 0x18(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x5590
jmp 0xb6f1
leaq 0xcf(%rsp), %rdi
callq 0x5450
leaq 0xd0(%rsp), %rdi
callq 0x48980
jmp 0xb70d
leaq 0xd0(%rsp), %rdi
callq 0x5650
cmpq $0x0, %rax
je 0xb745
xorl %eax, %eax
movl %eax, %esi
leaq 0xd0(%rsp), %rdi
callq 0x5850
movq %rax, 0x10(%rsp)
jmp 0xb738
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0xb794
movl $0x2, 0xb8(%rsp)
jmp 0xb8a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xcf(%rsp), %rdi
callq 0x5450
jmp 0xb8f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xb8d7
leaq 0x50(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x51b0
jmp 0xb7a8
movq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xb120
jmp 0xb7be
leaq 0x50(%rsp), %rdi
callq 0x5260
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb894
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x14b80
jmp 0xb7e9
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x51a0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x5650
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x5830
jmp 0xb822
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x54a0
jmp 0xb832
leaq 0x30(%rsp), %rdi
callq 0x5260
jmp 0xb894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5260
jmp 0xb8d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xb8cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5260
jmp 0xb8cd
leaq 0x70(%rsp), %rdi
callq 0xb5f0
movl $0x0, 0xb8(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x5260
movl 0xb8(%rsp), %eax
testl %eax, %eax
je 0xb8c8
jmp 0xb8c3
jmp 0xb680
jmp 0xb680
leaq 0x70(%rsp), %rdi
callq 0xb5f0
leaq 0xd0(%rsp), %rdi
callq 0x5260
jmp 0xb8f8
movq 0x28(%rsp), %rax
movb 0x2c(%rax), %al
andb $0x1, %al
addq $0x4e8, %rsp            # imm = 0x4E8
retq
movq 0xc0(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/timecontrol.h
// Function: Morat::TimeControl::TimeControl()
TimeControl(){
		method   = STATS;
		param    = 2;
		game     = 0;
		move     = 1;
		flexible = true;
		max_sims = 0;
		remain   = game;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x2, (%rax)
vmovsd 0x3f220(%rip), %xmm0    # 0x4c018
vmovsd %xmm0, 0x8(%rax)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rax)
vmovsd 0x3f202(%rip), %xmm0    # 0x4c010
vmovsd %xmm0, 0x18(%rax)
movb $0x1, 0x20(%rax)
movq $0x0, 0x28(%rax)
vmovsd 0x10(%rax), %xmm0
vmovsd %xmm0, 0x30(%rax)
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_ = from_str<int>(s);
		sizem1_ = size_ - 1;
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size();
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x101e0
testb $0x1, %al
jne 0xffca
movb $0x0, 0x47(%rsp)
jmp 0x10049
movq 0x10(%rsp), %rdi
callq 0x10220
movq 0x18(%rsp), %rsi
movb %al, (%rsi)
movsbl (%rsi), %eax
subl $0x1, %eax
movb %al, 0x1(%rsi)
leaq 0x20(%rsp), %rdi
callq 0x36fc0
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
leaq 0x20(%rsp), %rsi
callq 0x102a0
leaq 0x20(%rsp), %rdi
callq 0x10060
movq 0x18(%rsp), %rdi
callq 0x102d0
movq 0x18(%rsp), %rdi
movw %ax, 0x2(%rdi)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
callq 0x102d0
movq (%rsp), %rdi
movslq %eax, %rsi
callq 0x102f0
movq 0x18(%rsp), %rdi
callq 0x10390
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/../lib/string.h
// Function: int Morat::from_str<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T from_str(const std::string & str){
	std::istringstream sin(str);
	T ret;
	sin >> ret;
	return ret;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x5700
movq 0x10(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x5250
jmp 0x1025c
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x51f0
movl 0xc(%rsp), %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x51f0
movq 0x20(%rsp), %rdi
callq 0x5760
nopl (%rax)
// File: tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, pos.xy, 1, edges(x, y), init_pattern(pos));
			}
		}
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x4e(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xff00
movq 0x18(%rsp), %rdi
movw 0x4e(%rsp), %ax
movw %ax, 0x6(%rdi)
movw $0x0, 0x4(%rdi)
leaq 0x5d0ef(%rip), %rax     # 0x6d4bc
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x5d0e7(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x9(%rdi)
addq $0x28, %rdi
callq 0x10160
movl $0x0, 0x48(%rsp)
movq 0x18(%rsp), %rcx
movl 0x48(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x10511
movl $0x0, 0x44(%rsp)
movq 0x18(%rsp), %rcx
movl 0x44(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x104ff
movq 0x18(%rsp), %rdi
movl 0x44(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x11370
movq 0x18(%rsp), %rdi
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x113c0
testb $0x1, %al
jne 0x1044d
jmp 0x1045b
leaq 0x5d067(%rip), %rax     # 0x6d4bb
movq %rax, 0x10(%rsp)
jmp 0x10469
leaq 0x5d058(%rip), %rax     # 0x6d4ba
movq %rax, 0x10(%rsp)
jmp 0x10469
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0x3f(%rsp)
movb 0x3f(%rsp), %al
movb %al, 0x27(%rsp)
movswl 0x42(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x44(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x36f50
movq 0x18(%rsp), %rdi
movl %eax, 0xc(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x11460
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %r8d
movq %rax, %r9
leaq 0x28(%rsp), %rdi
movl $0x1, %ecx
movzbl 0x27(%rsp), %esi
callq 0x11540
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movswq 0x42(%rsp), %rsi
callq 0x11590
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x1040b
jmp 0x10501
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x103ef
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/../lib/board_base.h
// Function: Morat::BoardBase<Morat::Hex::Board>::init_pattern(Morat::MoveValid const&)
Pattern init_pattern(const MoveValid& pos) {
		Pattern p = 0, j = 3;
		for (const MoveValid m : self()->neighbors_large(pos)) {
			if (!m.on_board())
				p |= j;
			j <<= 2;
		}
		return self()->pattern_reverse(p);
	}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x40(%rsp)
movq $0x3, 0x38(%rsp)
callq 0x116c0
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x116d0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11710
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11720
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x1151f
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rdi
callq 0x11730
testb $0x1, %al
jne 0x11501
movq 0x38(%rsp), %rax
orq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x114cd
movq (%rsp), %rdi
callq 0x116c0
movq 0x40(%rsp), %rdi
callq 0x11750
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::find_callback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int find_callback(const std::string & name){
		for(unsigned int i = 0; i < callbacks.size(); i++)
			if(callbacks[i].name == name)
				return i;
		return -1;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0xd960
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x13e24
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xd980
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x14550
testb $0x1, %al
jne 0x13e0b
jmp 0x13e15
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x13e2c
jmp 0x13e17
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x13dc0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::~AgentMCTS()
AgentMCTS::~AgentMCTS(){
	pool.pause();
	pool.set_num_threads(0);

	root.dealloc(ctmem);
	ctmem.compact();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x5495e(%rip), %rax     # 0x6c858
movq %rax, (%rdi)
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1a920
jmp 0x17f0b
movq 0x8(%rsp), %rdi
addq $0x54f0, %rdi           # imm = 0x54F0
xorl %esi, %esi
callq 0x1b770
jmp 0x17f20
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
addq $0x4130, %rsi           # imm = 0x4130
callq 0x1bb20
jmp 0x17f3d
movq 0x8(%rsp), %rdi
addq $0x4130, %rdi           # imm = 0x4130
vpxor %xmm1, %xmm1, %xmm1
vmovaps %xmm1, %xmm0
callq 0x1bbe0
jmp 0x17f58
movq 0x8(%rsp), %rdi
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1b9c0
movq 0x8(%rsp), %rdi
addq $0x4130, %rdi           # imm = 0x4130
callq 0x1ba30
movq 0x8(%rsp), %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
callq 0x1bab0
movq 0x8(%rsp), %rdi
callq 0x1e390
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xd890
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::set_ponder(bool)
void AgentMCTS::set_ponder(bool p){
	if(ponder != p){
		ponder = p;
		pool.pause();

		if(ponder)
			pool.resume();
	}
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb 0x58(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x18046
movq (%rsp), %rdi
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x58(%rdi)
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1a920
movq (%rsp), %rax
testb $0x1, 0x58(%rax)
je 0x18044
movq (%rsp), %rdi
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1ab60
jmp 0x18046
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::set_board(Morat::Hex::Board const&, bool)
void AgentMCTS::set_board(const Board & board, bool clear){
	pool.pause();

	nodes -= root.dealloc(ctmem);
	root = Node();
	root.exp.addwins(visitexpand+1);

	rootboard = board;

	if(ponder)
		pool.resume();
}

// Assembly:
subq $0x78, %rsp
movb %dl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1a920
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
movq %rdi, 0x10(%rsp)
addq $0x4130, %rsi           # imm = 0x4130
callq 0x1bb20
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x4110(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x4110(%rax)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1b5a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1c1d0
jmp 0x180d8
leaq 0x30(%rsp), %rdi
callq 0x1bab0
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
addq $0x10, %rdi
movl 0xa8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x1c2a0
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x10, %rdi
callq 0x1c2d0
movq 0x8(%rsp), %rax
testb $0x1, 0x58(%rax)
je 0x18152
movq 0x8(%rsp), %rdi
addq $0x54f0, %rdi           # imm = 0x54F0
callq 0x1ab60
jmp 0x18152
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1bab0
jmp 0x18157
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5760
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::gamelen() const
double AgentMCTS::gamelen() const {
	DepthStats len;
	for(auto & t : pool)
		len += t->gamelen;
	return len.avg();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1ad70
movq 0x8(%rsp), %rax
addq $0x54f0, %rax           # imm = 0x54F0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ad80
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1adb0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1ade0
testb $0x1, %al
jne 0x18860
jmp 0x18894
leaq 0x20(%rsp), %rdi
callq 0x1ae20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rsi
addq $0x12148, %rsi          # imm = 0x12148
leaq 0x30(%rsp), %rdi
callq 0x1ae30
leaq 0x20(%rsp), %rdi
callq 0x1aec0
jmp 0x1884b
leaq 0x30(%rsp), %rdi
callq 0x1c580
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::get_pv(std::vector<Morat::Move, std::allocator<Morat::Move>> const&) const
std::vector<Move> AgentMCTS::get_pv(const vecmove& moves) const {
	vecmove pv;

	const Node * n = & root;
	Side turn = rootboard.to_play();
	unsigned int i = 0;
	while(n && !n->children.empty()){
		Move m = (i < moves.size() ? moves[i++] : return_move(n, turn));
		pv.push_back(m);
		n = find_child(n, m);
		turn = ~turn;
	}

	if(pv.size() == 0)
		pv.push_back(Move(M_RESIGN));

	return pv;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x118a0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x40e0, %rax           # imm = 0x40E0
movq %rax, 0x60(%rsp)
addq $0x10, %rdi
callq 0x1a8a0
movb %al, 0x40(%rsp)
jmp 0x1890c
movb 0x40(%rsp), %al
movb %al, 0x5f(%rsp)
movl $0x0, 0x48(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x60(%rsp)
movb %al, 0x27(%rsp)
je 0x18948
movq 0x60(%rsp), %rdi
addq $0x28, %rdi
callq 0x1b500
movb %al, 0x26(%rsp)
jmp 0x1893e
movb 0x26(%rsp), %al
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x18955
jmp 0x18a46
movl 0x48(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1c5d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1899a
movq 0x70(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rsp)
movl %eax, %eax
movl %eax, %esi
callq 0x1c5f0
movw (%rax), %ax
movw %ax, 0x46(%rsp)
jmp 0x189c9
movq 0x38(%rsp), %rdi
movq 0x60(%rsp), %rsi
movb 0x5f(%rsp), %al
movb %al, 0x45(%rsp)
movzbl 0x45(%rsp), %edx
xorl %ecx, %ecx
callq 0x18ab0
movw %ax, 0x16(%rsp)
jmp 0x189bf
movw 0x16(%rsp), %ax
movw %ax, 0x46(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x46(%rsp), %rsi
callq 0x1c610
jmp 0x189da
movq 0x38(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x46(%rsp), %rdx
callq 0x190a0
movq %rax, 0x8(%rsp)
jmp 0x189f5
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movb 0x5f(%rsp), %al
movb %al, 0x43(%rsp)
movzbl 0x43(%rsp), %edi
callq 0x1c680
movb %al, 0x7(%rsp)
jmp 0x18a17
movb 0x7(%rsp), %al
movb %al, 0x44(%rsp)
movb 0x44(%rsp), %al
movb %al, 0x5f(%rsp)
jmp 0x1891c
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x11920
jmp 0x18a9d
movq 0x28(%rsp), %rdi
callq 0x1c5d0
cmpq $0x0, %rax
jne 0x18a7a
leaq 0x41(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xff00
jmp 0x18a67
movq 0x28(%rsp), %rdi
leaq 0x41(%rsp), %rsi
callq 0x1c6c0
jmp 0x18a78
jmp 0x18a7a
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x18a90
movq 0x28(%rsp), %rdi
callq 0x11920
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5760
nopw (%rax,%rax)
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::find_child(Morat::Hex::AgentMCTS::Node const*, Morat::Move const&) const
AgentMCTS::Node * AgentMCTS::find_child(const Node * node, const Move & move) const {
	for(auto & c : node->children)
		if(c.move == move)
			return &c;
	return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1c340
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1c390
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x1912c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x24, %rdi
movq 0x28(%rsp), %rsi
callq 0x1c3e0
testb $0x1, %al
jne 0x1910e
jmp 0x1911a
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x19135
jmp 0x1911c
movq 0x18(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
jmp 0x190df
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::garbage_collect(Morat::Hex::AgentMCTS::Node&, Morat::Side)
void AgentMCTS::garbage_collect(Node& node, Side to_play){
	for (auto& child : node.children) {
		if (child.children.num() == 0)
			continue;

		if ((node.outcome.solved() &&       // parent is solved
		     child.exp.num() > gcsolved &&  // keep the heavy nodes
		     (node.outcome != to_play ||    // loss or draw, keep the everything
		      child.outcome == to_play)) || // found the win, keep the proof tree
		    (!node.outcome.solved() &&      // parent isn't solved,
		     child.exp.num() > (child.outcome.solved() ?
		      gcsolved :                    // only keep the heavy proof tree
		      gclimit)) ){                  // but the light area still being worked on
			garbage_collect(child, ~to_play);
		} else {
			nodes -= child.dealloc(ctmem);
		}
	}
}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movb %al, 0x67(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1c340
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1c390
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x1975a
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x1a560
cmpl $0x0, %eax
jne 0x1960c
jmp 0x19747
movq 0x50(%rsp), %rdi
addq $0x22, %rdi
callq 0x1cb10
testb $0x1, %al
jne 0x19620
jmp 0x19670
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x1c800
movq 0x20(%rsp), %rcx
movl 0xac(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x19670
movq 0x50(%rsp), %rdi
addq $0x22, %rdi
leaq 0x67(%rsp), %rsi
callq 0x1cb50
testb $0x1, %al
jne 0x196dd
movq 0x30(%rsp), %rdi
addq $0x22, %rdi
leaq 0x67(%rsp), %rsi
callq 0x1c7c0
testb $0x1, %al
jne 0x196dd
movq 0x50(%rsp), %rdi
addq $0x22, %rdi
callq 0x1cb10
testb $0x1, %al
jne 0x19713
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x1c800
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x22, %rdi
callq 0x1cb10
testb $0x1, %al
jne 0x196ad
jmp 0x196be
movq 0x20(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x196cd
movq 0x20(%rsp), %rax
movl 0x4118(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x19713
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x67(%rsp), %al
movb %al, 0x2e(%rsp)
movzbl 0x2e(%rsp), %edi
callq 0x1c680
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %edx
callq 0x19590
jmp 0x19745
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdi
addq $0x4130, %rsi           # imm = 0x4130
callq 0x1bb20
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x4110(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x4110(%rax)
jmp 0x19747
movq 0x40(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x40(%rsp)
jmp 0x195da
addq $0x68, %rsp
retq
nop
// File: tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::gen_sgf(Morat::SGFPrinter<Morat::Move>&, unsigned int, Morat::Hex::AgentMCTS::Node const&, Morat::Side) const
void AgentMCTS::gen_sgf(SGFPrinter<Move> & sgf, unsigned int limit, const Node & node, Side side) const {
	for(auto & child : node.children){
		if(child.exp.num() >= limit && (side != node.outcome || child.outcome == node.outcome)){
			sgf.child_start();
			sgf.move(side, child.move);
			sgf.comment(child.to_s());
			gen_sgf(sgf, limit, child, ~side);
			sgf.child_end();
		}
	}
}

// Assembly:
subq $0xb8, %rsp
movb %r8b, %al
movb %al, 0xb7(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movq %rcx, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1c340
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1c390
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x78(%rsp), %rax
je 0x1996c
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
addq $0x10, %rdi
callq 0x1c800
movl 0x9c(%rsp), %ecx
cmpq %rcx, %rax
jb 0x19951
movq 0x90(%rsp), %rsi
addq $0x22, %rsi
leaq 0xb7(%rsp), %rdi
callq 0x1cb90
testb $0x1, %al
jne 0x19856
movq 0x70(%rsp), %rdi
addq $0x22, %rdi
movq 0x90(%rsp), %rsi
addq $0x22, %rsi
callq 0x1c810
testb $0x1, %al
jne 0x19856
jmp 0x19951
movq 0xa0(%rsp), %rdi
callq 0x1cbd0
movq 0xa0(%rsp), %rdi
movb 0xb7(%rsp), %al
movb %al, 0x6f(%rsp)
movq 0x70(%rsp), %rax
movw 0x24(%rax), %ax
movw %ax, 0x6c(%rsp)
movzwl 0x6c(%rsp), %edx
movzbl 0x6f(%rsp), %esi
callq 0x1cd70
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x14ed0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1cf70
jmp 0x198c5
leaq 0x48(%rsp), %rdi
callq 0x5260
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0xb7(%rsp), %al
movb %al, 0x3a(%rsp)
movzbl 0x3a(%rsp), %edi
callq 0x1c680
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
movb %al, 0x3b(%rsp)
movzbl 0x3b(%rsp), %r8d
callq 0x19760
movq 0xa0(%rsp), %rdi
callq 0x1d090
jmp 0x19951
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5260
jmp 0x19974
jmp 0x19953
movq 0x80(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x80(%rsp)
jmp 0x197d8
addq $0xb8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5760
nop