LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wichtounet[P]articles/src/threads/part1/Hello2.cpp
// Function: main
int main(){
    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([](){
            std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x16d0
movl $0x0, 0x44(%rsp)
cmpl $0x5, 0x44(%rsp)
jge 0x130b
leaq 0x38(%rsp), %rdi
leaq 0x37(%rsp), %rsi
callq 0x13a0
jmp 0x12b6
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x16e0
jmp 0x12c7
leaq 0x38(%rsp), %rdi
callq 0x1710
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x129e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x138a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1710
jmp 0x138a
leaq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1730
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1760
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1790
testb $0x1, %al
jne 0x1348
jmp 0x136f
leaq 0x10(%rsp), %rdi
callq 0x17d0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x1120
jmp 0x1361
jmp 0x1363
leaq 0x10(%rsp), %rdi
callq 0x17e0
jmp 0x1333
movl $0x0, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1800
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0x1800
movq 0x28(%rsp), %rdi
callq 0x1130
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline sink error(std::string message) {
    return sink(sink::action,
        [m = std::move(message)](const char*) -> bool {
            throw user_option_error(m);
        });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x50b0
jmp 0x3fc7
leaq -0x38(%rbp), %rdi
callq 0x50d0
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x50d0
movq -0x40(%rbp), %rdi
callq 0x3320
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::usage_error(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void usage_error(const char* argv0, const std::string& usage_str, const std::string& parse_err, const std::string& prefix = "Usage: ") {
    const char* basename = std::strrchr(argv0, '/');
    basename = basename? basename+1: argv0;

    std::cerr << basename << ": " << parse_err << "\n";
    std::cerr << prefix << basename << " " << usage_str << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x3240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x47df
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x47e7
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq 0x167f6(%rip), %rdi     # 0x1aff0
callq 0x31d0
movq %rax, %rdi
leaq 0xc8f0(%rip), %rsi      # 0x110f9
callq 0x31d0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31c0
movq %rax, %rdi
leaq 0xc8af(%rip), %rsi      # 0x110d3
callq 0x31d0
movq -0x20(%rbp), %rsi
movq 0x167bc(%rip), %rdi     # 0x1aff0
callq 0x31c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xc8ab(%rip), %rsi      # 0x110fa
callq 0x31d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x31c0
movq %rax, %rdi
leaq 0xc869(%rip), %rsi      # 0x110d3
callq 0x31d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: void to::option::init_<char const (&) [5], std::function<int (int)>>(to::option_flag, char const (&) [5], std::function<int (int)>&&)
void init_(enum option_flag f, Rest&&... rest) {
        is_flag      |= f & flag;
        is_ephemeral |= f & ephemeral;
        is_single    |= f & single;
        is_mandatory |= f & mandatory;
        is_exit      |= f & exit;
        is_stop      |= f & stop;
        is_lax       |= f & lax;
        init_(std::forward<Rest>(rest)...);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %edx
movl 0x68(%rax), %ecx
orl %edx, %ecx
andb $0x1, %cl
movb %cl, 0x68(%rax)
movl -0xc(%rbp), %edx
andl $0x2, %edx
movzbl 0x69(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x69(%rax)
movl -0xc(%rbp), %edx
andl $0x4, %edx
movzbl 0x6a(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x6a(%rax)
movl -0xc(%rbp), %edx
andl $0x8, %edx
movzbl 0x6b(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x6b(%rax)
movl -0xc(%rbp), %edx
andl $0x10, %edx
movzbl 0x6c(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x6c(%rax)
movl -0xc(%rbp), %edx
andl $0x20, %edx
movzbl 0x6d(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x6d(%rax)
movl -0xc(%rbp), %edx
andl $0x40, %edx
movzbl 0x6e(%rax), %ecx
andl $0x1, %ecx
orl %edx, %ecx
setne 0x6e(%rax)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7a20
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x79a0
jmp 0x7683
leaq -0x48(%rbp), %rdi
callq 0x6160
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6160
movq -0x50(%rbp), %rdi
callq 0x3320
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::saved_options::as_arglist() const
arglist as_arglist() const {
        arglist A;

        for (auto& a: *this) A.arg_data.push_back(const_cast<char*>(a.c_str()));
        A.arg_data.push_back(nullptr);
        A.argv = A.arg_data.data();
        A.argc = A.arg_data.size()-1;
        return A;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xbf90
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfe0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc010
testb $0x1, %al
jne 0x9954
jmp 0x99b0
leaq -0x28(%rbp), %rdi
callq 0xc050
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x38(%rbp)
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
callq 0x30b0
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xc070
jmp 0x998c
jmp 0x998e
leaq -0x28(%rbp), %rdi
callq 0xc0a0
jmp 0x9941
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xa4f0
jmp 0x9a16
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xc070
jmp 0x99cb
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0xc0c0
movq -0x70(%rbp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0xc0e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq $0x1, %rcx
movl %ecx, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x9a09
movq -0x70(%rbp), %rdi
callq 0xa4f0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3320
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::option::longest_label[abi:cxx11]() const
std::string longest_label() const {
        const std::string* p = 0;
        for (auto& k: keys) {
            if (!p || k.label.size()>p->size()) p = &k.label;
        }
        return p? *p: std::string{};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, -0x18(%rbp)
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb100
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb130
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb360
testb $0x1, %al
jne 0xa28c
jmp 0xa2d7
leaq -0x28(%rbp), %rdi
callq 0xb3d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa2c2
movq -0x38(%rbp), %rdi
callq 0x3150
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3150
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0xa2ca
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xa2cc
leaq -0x28(%rbp), %rdi
callq 0xb3f0
jmp 0xa279
cmpq $0x0, -0x18(%rbp)
je 0xa2ed
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x30c0
jmp 0xa2f6
movq -0x48(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::shift(unsigned int)
void shift(unsigned n = 1) {
        if (!n) return;

        char** skip = argv;
        while (*skip && n) ++skip, --n;

        argc -= (skip-argv);
        auto p = argv;
        do { *p++ = *skip; } while (*skip++);

        optoff = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xddee
jmp 0xde92
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0xde13
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xde1c
jmp 0xde33
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xddfa
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rax), %rcx
subq %rcx, %rsi
sarq $0x3, %rsi
movq (%rax), %rcx
movslq (%rcx), %rdx
subq %rsi, %rdx
movl %edx, (%rcx)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rax)
jne 0xde59
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_flag(to::key const&)
maybe<match_result> match_flag(const key& k) {
        if (k.style==key::compact) {
            if (auto m = match_compact_key(k.label.c_str())) {
                if ((*argv)[optoff+*m]) 
                    return match_result{nullptr, 0, *m};
                else
                    return match_result{nullptr, 1, 0};
            }
        }
        else if (!optoff && k.label==*argv) {
            return match_result{nullptr, 1, 0};
        }

        return nothing;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0xe12b
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0xe5f0
leaq -0x20(%rbp), %rdi
callq 0xe6f0
testb $0x1, %al
jne 0xe053
jmp 0xe10e
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x88(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x8c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe710
movl -0x8c(%rbp), %ecx
movq %rax, %rdx
movq -0x88(%rbp), %rax
addl (%rdx), %ecx
movl %ecx, %ecx
cmpb $0x0, (%rax,%rcx)
je 0xe0e0
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe710
movq -0x80(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xe730
jmp 0xe0bd
movl $0x1, -0x40(%rbp)
jmp 0xe115
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe760
jmp 0xe18c
movq -0x80(%rbp), %rdi
movq $0x0, -0x50(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x0, -0x44(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xe730
jmp 0xe105
movl $0x1, -0x40(%rbp)
jmp 0xe115
movl $0x0, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe760
movl -0x40(%rbp), %eax
testl %eax, %eax
je 0xe129
jmp 0xe127
jmp 0xe17f
jmp 0xe176
movq -0x70(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xe174
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0xe790
testb $0x1, %al
jne 0xe14f
jmp 0xe174
movq -0x80(%rbp), %rdi
movq $0x0, -0x60(%rbp)
movl $0x1, -0x58(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xe730
jmp 0xe17f
jmp 0xe176
movq -0x80(%rbp), %rdi
callq 0xe7c0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_compact_key(char const*)
maybe<unsigned> match_compact_key(const char* k) {
        unsigned keylen = std::strlen(k);

        unsigned prefix_max = std::min(keylen-1, optoff);
        for (std::size_t l = 0; l<=prefix_max; ++l) {
            if (l && strncmp(*argv, k, l)) break;
            if (strncmp(*argv+optoff, k+l, keylen-l)) continue;

            return keylen-l;
        }

        return nothing;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
movq -0x40(%rbp), %rsi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
addq $0x10, %rsi
leaq -0x24(%rbp), %rdi
callq 0xe7e0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
cmpq %rcx, %rax
ja 0xe6d4
cmpq $0x0, -0x30(%rbp)
je 0xe67c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x30e0
cmpl $0x0, %eax
je 0xe67c
jmp 0xe6d4
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rdi
movl 0x10(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
subq -0x30(%rbp), %rdx
callq 0x30e0
cmpl $0x0, %eax
je 0xe6aa
jmp 0xe6c3
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %eax
subq -0x30(%rbp), %rax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xe820
jmp 0xe6dd
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe64a
movq -0x50(%rbp), %rdi
callq 0xe850
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/game.cc
// Function: main
int main()
{
	string resp;
	// distributions and engines have state,
    // they must be defined outside the loop!
	default_random_engine e;  

	// 50/50 odds by default
	bernoulli_distribution b(0.55); // give the house a slight edge

	do {
		bool first = b(e);    // if true, the program will go first
		cout << (first ? "We go first" 
	                   : "You get to go first") << endl;
		// play the game passing the indicator of who goes first
		cout << ((play(first)) ? "sorry, you lost" 
	                           : "congrats, you won") << endl;
		cout << "play again? Enter 'yes' or 'no'" << endl;
	} while (cin >> resp && resp[0] == 'y');

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10b0
leaq -0x30(%rbp), %rdi
callq 0x1400
jmp 0x1276
leaq -0x48(%rbp), %rdi
movsd 0xd86(%rip), %xmm0      # 0x2008
callq 0x1420
jmp 0x1289
jmp 0x128b
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1450
movb %al, -0x4a(%rbp)
jmp 0x129d
movb -0x4a(%rbp), %al
andb $0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %cl
leaq 0xda1(%rip), %rax       # 0x2050
leaq 0xda6(%rip), %rsi       # 0x205c
testb $0x1, %cl
cmovneq %rax, %rsi
movq 0x2d0c(%rip), %rdi      # 0x3fd0
callq 0x1070
movq %rax, -0x58(%rbp)
jmp 0x12cf
movq -0x58(%rbp), %rdi
movq 0x2ce6(%rip), %rsi      # 0x3fc0
callq 0x1080
jmp 0x12e1
movzbl -0x49(%rbp), %edi
andl $0x1, %edi
callq 0x1230
movb %al, %cl
leaq 0xd7a(%rip), %rax       # 0x2070
leaq 0xd83(%rip), %rsi       # 0x2080
testb %cl, %cl
cmovneq %rax, %rsi
movq 0x2cc6(%rip), %rdi      # 0x3fd0
callq 0x1070
movq %rax, -0x60(%rbp)
jmp 0x1315
movq -0x60(%rbp), %rdi
movq 0x2ca0(%rip), %rsi      # 0x3fc0
callq 0x1080
jmp 0x1327
movq 0x2ca2(%rip), %rdi      # 0x3fd0
leaq 0xd5d(%rip), %rsi       # 0x2092
callq 0x1070
movq %rax, -0x68(%rbp)
jmp 0x1340
movq -0x68(%rbp), %rdi
movq 0x2c75(%rip), %rsi      # 0x3fc0
callq 0x1080
jmp 0x1352
jmp 0x1354
movq 0x2c85(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x10a0
movq %rax, -0x70(%rbp)
jmp 0x136a
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1090
movb %al, -0x71(%rbp)
jmp 0x1382
movb -0x71(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x72(%rbp)
jne 0x1391
jmp 0x13b4
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x10e0
movq %rax, -0x80(%rbp)
jmp 0x13a4
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x79, %eax
sete %al
movb %al, -0x72(%rbp)
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x128b
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rdi
callq 0x10d0
nopl (%rax)
// File: arwn[P]baby-shark/babyshark.cpp
// Function: main
int
main(void)
{
  using namespace std::chrono_literals;
  Bullshit baby_shark_machine;
  char c;
  for (int i = 0; i < 100; i++) {
    baby_shark_machine.step();
  }
  return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x24d0
movl $0x0, -0x48(%rbp)
cmpl $0x64, -0x48(%rbp)
jge 0x24a4
leaq -0x40(%rbp), %rdi
callq 0x3b70
jmp 0x2480
jmp 0x2482
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x246f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ba0
jmp 0x24bd
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ba0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: arwn[P]baby-shark/babyshark.cpp
// Function: Bullshit::execute_state()
void execute_state()
  {
    std::cout << sharktable[state] << ' ' << std::flush;
    std::string command =
      "aplay audio/" + sharktable[state] + ".wav 2>/dev/null >/dev/null";
    system(command.c_str());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
movl (%rax), %eax
movl %eax, %esi
callq 0x5fa0
movq %rax, %rsi
movq 0x517e(%rip), %rdi      # 0xafd0
callq 0x2190
movq %rax, %rdi
movl $0x20, %esi
callq 0x2230
movq %rax, %rdi
movq 0x516a(%rip), %rsi      # 0xafd8
callq 0x21e0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x5fa0
movq %rax, %rdx
leaq 0x122b(%rip), %rsi      # 0x70b9
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6010
movq -0x60(%rbp), %rsi
leaq 0x1220(%rip), %rdx      # 0x70c6
leaq -0x28(%rbp), %rdi
callq 0x5fc0
jmp 0x5eb1
leaq -0x48(%rbp), %rdi
callq 0x2100
leaq -0x28(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
callq 0x2170
jmp 0x5ecd
leaq -0x28(%rbp), %rdi
callq 0x2100
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2100
jmp 0x5f08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::init(unsigned long)
void Vertices::init(size_t size) {
	Vertex v;
	for(size_t i = 0; i != size; i++) {
		v.set_index(i);
		vertices.push_back(v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3370
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x25fd
movq -0x20(%rbp), %rax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
callq 0x3390
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x33b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x25c9
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::cut_vertex_from(bool const* const*, Vertices&, int)
void Vertices::cut_vertex_from( const bool * const *conn, Vertices &v, int vertex_index ) {
	vertices.resize(0);
	for(vvec_type::const_iterator iter = v.vertices.begin(); iter != v.vertices.end(); ++iter) {
		if(conn[vertex_index][iter->get_index()])
			vertices.push_back(*iter);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3420
movq -0x18(%rbp), %rdi
callq 0x34b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34e0
movq -0x18(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3520
testb $0x1, %al
jne 0x2672
jmp 0x26c4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3590
movq %rax, %rdi
callq 0x35b0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
testb $0x1, (%rax,%rcx)
je 0x26b7
leaq -0x28(%rbp), %rdi
callq 0x35c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x33b0
jmp 0x26b9
leaq -0x28(%rbp), %rdi
callq 0x35e0
jmp 0x2652
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::set_degrees(bool const* const*)
void Vertices::set_degrees(const bool *const *conn) {
	//set degrees to 0
	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		iter->set_degree(0);
	}

	for(vvec_type::iterator iter_i = vertices.begin(); iter_i != vertices.end(); ++iter_i) {
		for(vvec_type::iterator iter_j = iter_i + 1; iter_j != vertices.end(); ++iter_j) {
			if(conn[iter_i->get_index()][iter_j->get_index()]) {
				iter_i->inc_degree();
				iter_j->inc_degree();
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x34b0
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3560
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x2791
jmp 0x27af
leaq -0x18(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
xorl %esi, %esi
callq 0x3730
leaq -0x18(%rbp), %rdi
callq 0x3750
jmp 0x2771
movq -0x48(%rbp), %rdi
callq 0x34b0
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3560
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x27df
jmp 0x289d
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3770
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3560
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x2811
jmp 0x288d
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x35b0
movl %eax, %ecx
movq -0x58(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x35b0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
testb $0x1, (%rax,%rcx)
je 0x287d
leaq -0x28(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x37b0
leaq -0x38(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x37b0
jmp 0x287f
leaq -0x38(%rbp), %rdi
callq 0x3750
jmp 0x27f1
jmp 0x288f
leaq -0x28(%rbp), %rdi
callq 0x3750
jmp 0x27bc
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: color_conflict(bool const* const*, int, std::vector<int, std::allocator<int>> const&)
bool color_conflict(const bool *const * conn, int vindex, const std::vector<int> &color) {
	for(std::vector<int>::const_iterator iter = color.begin(); iter != color.end(); ++iter) {
		if(conn[*iter][vindex])
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3970
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x39e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x39a0
testb $0x1, %al
jne 0x2d00
jmp 0x2d3c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3a10
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x2d2f
movb $0x1, -0x1(%rbp)
jmp 0x2d40
jmp 0x2d31
leaq -0x28(%rbp), %rdi
callq 0x3a30
jmp 0x2ce0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::print()
void Vertices::print()
{
	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_index() + 1<<"  ";
	}
	std::cout<<std::endl;

	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_degree()<<"  ";
	}
	std::cout<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x34b0
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3560
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x319d
jmp 0x31d9
leaq -0x10(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x35b0
movl %eax, %esi
addl $0x1, %esi
movq 0xfe1e(%rip), %rdi      # 0x12fd8
callq 0x22e0
movq %rax, %rdi
leaq 0x8e3b(%rip), %rsi      # 0xc004
callq 0x21f0
leaq -0x10(%rbp), %rdi
callq 0x3750
jmp 0x317d
movq 0xfdf8(%rip), %rdi      # 0x12fd8
movq 0xfde1(%rip), %rsi      # 0x12fc8
callq 0x2230
movq -0x30(%rbp), %rdi
callq 0x34b0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3560
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x3219
jmp 0x3252
leaq -0x20(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x3830
movl %eax, %esi
movq 0xfda5(%rip), %rdi      # 0x12fd8
callq 0x22e0
movq %rax, %rdi
leaq 0x8dc2(%rip), %rsi      # 0xc004
callq 0x21f0
leaq -0x20(%rbp), %rdi
callq 0x3750
jmp 0x31f9
movq 0xfd7f(%rip), %rdi      # 0x12fd8
movq 0xfd68(%rip), %rsi      # 0x12fc8
callq 0x2230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::print_colors()
void Vertices::print_colors(){
	int pre_color = vertices.begin()->get_degree();
	int count = 1;
	for(vvec_type::iterator iter = vertices.begin() + 1; iter != vertices.end(); ++iter) {
		if(pre_color != iter->get_degree()) {
			count = 1;
			std::cout<<count<<"  ";
			pre_color = iter->get_degree();
			continue;
		}
		++count;
	}
	std::cout<<count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x34b0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x3830
movq -0x40(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl $0x1, -0x1c(%rbp)
callq 0x34b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3770
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x36d0
testb $0x1, %al
jne 0x32e7
jmp 0x3359
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x3830
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
je 0x3342
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq 0xfcc0(%rip), %rdi      # 0x12fd8
callq 0x22e0
movq %rax, %rdi
leaq 0x8cdd(%rip), %rsi      # 0xc004
callq 0x21f0
leaq -0x28(%rbp), %rdi
callq 0x3710
movq %rax, %rdi
callq 0x3830
movl %eax, -0xc(%rbp)
jmp 0x334b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3750
jmp 0x32c7
movl -0x1c(%rbp), %esi
movq 0xfc75(%rip), %rdi      # 0x12fd8
callq 0x22e0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/app/tEvent.cpp
// Function: u::tEvent::onEvent2(u::Object*)
void onEvent2(Object *arg)
			{
				Event *event = (Event*)arg;
				//trace("onEvent2="+event->toString());
				event->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
				dispatchEvent(new Event(Event::PROGRESS))->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl $0x48, %edi
callq 0x414cb0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq $0x6195d8, %rsi         # imm = 0x6195D8
callq 0x4077e0
jmp 0x4064be
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x409000
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl $0x48, %edi
callq 0x414cb0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq $0x619630, %rsi         # imm = 0x619630
callq 0x4077e0
jmp 0x4064f8
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x409000
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl $0x48, %edi
callq 0x414cb0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq $0x6195d8, %rsi         # imm = 0x6195D8
callq 0x4077e0
jmp 0x406532
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x409000
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x413b20
jmp 0x40659f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x413b20
jmp 0x40659f
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x413b20
movq -0x20(%rbp), %rdi
callq 0x4be910
nopl (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Callback.cpp
// Function: u::Callback::operator==(u::Callback const&) const
bool Callback::operator==(const Callback& other) const
{
	bool ret = true;
	if(other.target != this->target) ret = false;
	if(ret && other.function != this->function) ret = false;
	if(ret && other.arg != this->arg) ret = false;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq 0x38(%rcx), %rax
je 0x40732a
movb $0x0, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x407369
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x48(%rax), %rdx
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rsi
cmpq %rax, %rcx
setne %al
cmpq $0x0, %rcx
setne %cl
cmpq %rsi, %rdx
setne %dl
andb %dl, %cl
orb %cl, %al
testb $0x1, %al
jne 0x407365
jmp 0x407369
movb $0x0, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x407385
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpq 0x50(%rcx), %rax
je 0x407385
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: enbock[P]Warp10Server/ulib/src/Event.cpp
// Function: u::Event::toString()
String u::Event::toString()
{
	String str = "[" + className();
	str += " type=" + *_type;
	str += " target=" + (_target!=null?_target->toString():"null");
	str += "]";
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x150(%rbp)
movq %rdi, %rax
movq %rax, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x140(%rbp)
movb $0x0, -0x11(%rbp)
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
leaq -0x58(%rbp), %rdx
leaq 0x1976fc(%rip), %rsi    # 0x59f06a
leaq -0x38(%rbp), %rdi
callq 0x405790
jmp 0x407979
movq -0x150(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x40e0a0
jmp 0x40798b
leaq -0x38(%rbp), %rdi
callq 0x48dbd0
leaq -0x90(%rbp), %rdi
callq 0x404d10
movq -0x140(%rbp), %rax
movq 0x38(%rax), %rdx
addq $0x38, %rdx
leaq 0x1977f4(%rip), %rsi    # 0x59f1aa
leaq -0xc0(%rbp), %rdi
callq 0x407c00
jmp 0x4079c4
movq -0x150(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x48f2f0
jmp 0x4079dd
leaq -0xc0(%rbp), %rdi
callq 0x48dbd0
movq -0x140(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x407a16
movq -0x140(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x138(%rbp), %rdi
callq *%rax
jmp 0x407a14
jmp 0x407a2d
leaq 0x19d5a2(%rip), %rsi    # 0x5a4fbf
leaq -0x138(%rbp), %rdi
callq 0x40e000
jmp 0x407a2b
jmp 0x407a2d
leaq -0x100(%rbp), %rdx
leaq 0x19771d(%rip), %rsi    # 0x59f158
leaq -0xe0(%rbp), %rdi
callq 0x405790
jmp 0x407a49
movq -0x150(%rbp), %rdi
addq $0x38, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x48f2f0
jmp 0x407a62
leaq -0xe0(%rbp), %rdi
callq 0x48dbd0
leaq -0x138(%rbp), %rdi
callq 0x404d10
movq -0x150(%rbp), %rdi
addq $0x38, %rdi
leaq 0x1b6fda(%rip), %rsi    # 0x5bea66
callq 0x48f3d0
jmp 0x407a93
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x407b66
jmp 0x407b5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x407ad5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48dbd0
leaq -0x90(%rbp), %rdi
callq 0x404d10
jmp 0x407b82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x407b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x48dbd0
jmp 0x407b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x407b4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x48dbd0
leaq -0x138(%rbp), %rdi
callq 0x404d10
jmp 0x407b76
movq -0x150(%rbp), %rdi
callq 0x404d10
movq -0x148(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x150(%rbp), %rdi
callq 0x404d10
movq -0x98(%rbp), %rdi
callq 0x4be910
nop
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::operator=(u::EventDispatcher&)
EventDispatcher& EventDispatcher::operator=(EventDispatcher& value)
{
	int64 i, l, j, m;
	_eventVector *src;
	Vector<Callback> *dst;

	value.lock();
	lock();

	l = value._eventList.size();
	for(i=0; i<l; i++)
	{
		src = &value._eventList.at(i);
		dst = getEventVector(src->type);
		if(dst == null)
		{
			dst = addEventVector(src->type);
		}
		m = src->list.size();
		for(j=0; j<m; j++)
		{
			dst->push_back(src->list.at(j));
		}
	}

	unlock();
	value.unlock();
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40d7d0
movq -0x48(%rbp), %rdi
callq 0x40d7d0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x409cb0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x408012
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x409a90
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x408c90
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x407f9d
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x408d30
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
addq $0x38, %rdi
callq 0x409ce0
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x407fff
movq -0x40(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movq -0x28(%rbp), %rsi
callq 0x409b40
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x409d10
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x407fba
jmp 0x408001
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x407f47
movq -0x48(%rbp), %rdi
callq 0x40d740
movq -0x10(%rbp), %rdi
callq 0x40d740
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::delEventVector(u::String const*)
void EventDispatcher::delEventVector(const String* type)
{
	int64 i, l;

	l = _eventList.size();
	for(i=0; i<l; i++)
	{
		_eventVector* entry = &_eventList.at(i);
		if(entry->type == type)
		{
			_eventList.erase(i);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x409cb0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x408c84
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x409a90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x408c74
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x409e90
jmp 0x408c84
jmp 0x408c76
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x408c31
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::getEventVector(u::String const*)
Vector<Callback>* EventDispatcher::getEventVector(const String* type)
{
	int64 i, l;

	l = _eventList.size();
	for(i=0; i<l; i++)
	{
		_eventVector* entry = &_eventList.at(i);
		if(entry->type == type) return &(entry->list);
	}
	return null;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x409cb0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x408d0f
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x409a90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x408cff
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x408d17
jmp 0x408d01
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x408cc1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventVector(u::String const*)
Vector<Callback>* EventDispatcher::addEventVector(const String* type)
{
	_eventVector vec;
	int64 i;

	vec.type = type;
	i = _eventList.size();
	_eventList.push_back(vec);
	return &(_eventList.at(i).list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x407d70
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x70, %rdi
movq %rdi, -0x90(%rbp)
callq 0x409cb0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, -0x70(%rbp)
callq 0x409e00
jmp 0x408d96
movq -0x98(%rbp), %rdi
addq $0x70, %rdi
movq -0x70(%rbp), %rsi
callq 0x409a90
movq %rax, -0xa0(%rbp)
jmp 0x408db3
movq -0xa0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x409e70
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x409e70
movq -0x78(%rbp), %rdi
callq 0x4be910
nopl (%rax)
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventListener(u::String const&, u::Callback)
void EventDispatcher::addEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		vec = addEventVector(&type);
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i).target == callback.target)
		{
			unlock();
			return;
		}
	}

	vec->push_back(callback);
	unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x40d7d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x408c90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x408e4e
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x408d30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x409ce0
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x408ea4
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x409b40
movq -0x38(%rbp), %rcx
movq 0x38(%rax), %rax
cmpq 0x38(%rcx), %rax
jne 0x408e97
movq -0x30(%rbp), %rdi
callq 0x40d740
jmp 0x408ebe
jmp 0x408e99
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x408e65
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x409d10
movq -0x30(%rbp), %rdi
callq 0x40d740
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::removeEventListener(u::String const&, u::Callback)
void EventDispatcher::removeEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	//if(hasEventListener(type) == false) return;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		unlock();
		return;
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i) == callback)
		{
			vec->erase(i);
			break;
		}
	}

	if(vec->empty()) delEventVector(&type);

	unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x40d7d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x408c90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x408f1b
movq -0x30(%rbp), %rdi
callq 0x40d740
jmp 0x408fa2
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x409ce0
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x408f79
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x409b40
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x407300
testb $0x1, %al
jne 0x408f5d
jmp 0x408f6c
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x409b80
jmp 0x408f79
jmp 0x408f6e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x408f32
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x409bf0
testb $0x1, %al
jne 0x408f8c
jmp 0x408f99
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x408c00
movq -0x30(%rbp), %rdi
callq 0x40d740
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::hasEventListener(u::String const&)
bool EventDispatcher::hasEventListener(const String& type)
{
	lock();
	bool ret = getEventVector(&type) != null;
	unlock();

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x40d7d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x408c90
movq -0x20(%rbp), %rdi
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x40d740
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Mutex.cpp
// Function: u::Mutex::~Mutex()
Mutex::~Mutex()
{
	if(_isLocked == true) unlock();
	int ret = pthread_mutex_destroy(&_mutex);
#ifndef NDEBUG
	assert(ret == 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x20216d(%rip), %rcx    # 0x60f838
addq $0x10, %rcx
movq %rcx, (%rax)
movb 0x30(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x40d6ec
movq -0x18(%rbp), %rdi
callq 0x40d740
jmp 0x40d6ea
jmp 0x40d6ec
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x4f2c90
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x40d704
jmp 0x40d723
leaq 0x191e44(%rip), %rdi    # 0x59f54f
leaq 0x191e46(%rip), %rsi    # 0x59f558
movl $0x1b, %edx
leaq 0x191e5a(%rip), %rcx    # 0x59f578
callq 0x4d3570
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x405580
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::Object()
Object::Object() : Mutex()
{
	if(!__Object_mx_validObjects) __Object_mx_validObjects = new Mutex();
	if(!__Object_validObjects) __Object_validObjects = new std::vector<void const*>();

	__Object_mx_validObjects->lock();
	__Object_validObjects->push_back((void const*)this);
	__Object_mx_validObjects->unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x40d650
movq -0x28(%rbp), %rax
leaq 0x201fcc(%rip), %rcx    # 0x60f870
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x20bde5(%rip)    # 0x619698
jne 0x40d90a
movl $0x38, %edi
callq 0x414cb0
movq %rax, -0x30(%rbp)
jmp 0x40d8c5
movq -0x30(%rbp), %rdi
callq 0x40d650
jmp 0x40d8d0
movq -0x30(%rbp), %rax
movq %rax, 0x20bdbd(%rip)    # 0x619698
jmp 0x40d90a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x40d984
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x38, %esi
callq 0x413b20
jmp 0x40d984
cmpq $0x0, 0x20bd8e(%rip)    # 0x6196a0
jne 0x40d948
movl $0x18, %edi
callq 0x414cb0
movq %rax, -0x38(%rbp)
jmp 0x40d924
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x401090
movq -0x38(%rbp), %rdi
callq 0x40f0b0
movq -0x38(%rbp), %rax
movq %rax, 0x20bd58(%rip)    # 0x6196a0
movq 0x20bd49(%rip), %rdi    # 0x619698
callq 0x40d7d0
jmp 0x40d956
movq -0x28(%rbp), %rax
movq 0x20bd3f(%rip), %rdi    # 0x6196a0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x40f0d0
jmp 0x40d970
movq 0x20bd21(%rip), %rdi    # 0x619698
callq 0x40d740
jmp 0x40d97e
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x40d6b0
movq -0x10(%rbp), %rdi
callq 0x4be910
nopw %cs:(%rax,%rax)