LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lartu[P]polaris/src/libs/cpptrim.h
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim(std::string & line){
    //If the std::string is empty
    if(line.size() == 0) return;

    //If the string has only one character
    if(line.size() == 1 && !std::isspace(line[0])) return;

    //Left trim
    int first = 0;
    for(unsigned int i = 0; i < line.size(); ++i){
        if (!std::isspace(line[i])){
            first = i;
            break;
        }
    }

    //Right trim
    int last = 0;
    for(unsigned int i = line.size()-1; i >= 0; --i){
        if (!std::isspace(line[i])){
            last = i+1;
            break;
        }
        //--i will break with unsigned int when reaching 0, so we check
        //if i == 0 and, if it is and it's not a space, we break
        if(i == 0){
            last = 0;
            break;
        }
    }

    //Trim the std::string
    line = line.substr(first, last-first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3210
cmpq $0x0, %rax
jne 0x3730
jmp 0x384e
movq -0x8(%rbp), %rdi
callq 0x3210
cmpq $0x1, %rax
jne 0x375e
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3500
movsbl (%rax), %edi
callq 0x3060
cmpl $0x0, %eax
jne 0x375e
jmp 0x384e
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3210
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x37b8
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3500
movsbl (%rax), %edi
callq 0x3060
cmpl $0x0, %eax
jne 0x37ab
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x37b8
jmp 0x37ad
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x376c
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3210
subq $0x1, %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jb 0x3817
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3500
movsbl (%rax), %edi
callq 0x3060
cmpl $0x0, %eax
jne 0x37fb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3817
cmpl $0x0, -0x18(%rbp)
jne 0x380a
movl $0x0, -0x14(%rbp)
jmp 0x3817
jmp 0x380c
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x37cf
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
movl %edx, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3300
movq -0x58(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3040
jmp 0x3845
leaq -0x38(%rbp), %rdi
callq 0x31c0
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 0x31c0
jmp 0x386b
jmp 0x386d
movq -0x40(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nop
// File: Lartu[P]polaris/src/polaris.cpp
// Function: main
int main(int argc, char** argv)
{
    polaris_setup();
    string file_path = check_args(argc, argv);
    string base_path = join_paths(".", get_working_directory(file_path));
    eval(load_source_file(file_path), base_path);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3b20
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3b60
leaq -0x71(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x34a0
movq -0x130(%rbp), %rdx
leaq 0xcbe8(%rip), %rsi      # 0x104b4
leaq -0x70(%rbp), %rdi
callq 0x33a0
jmp 0x38d7
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3170
jmp 0x38e9
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x4190
jmp 0x38fe
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x3ee0
jmp 0x3914
leaq -0xa8(%rbp), %rdi
callq 0x31c0
jmp 0x3922
leaq -0xc8(%rbp), %rdi
callq 0x31c0
jmp 0x3930
leaq -0x70(%rbp), %rdi
callq 0x31c0
jmp 0x393b
leaq -0x71(%rbp), %rdi
callq 0x3330
leaq -0x108(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3170
jmp 0x3956
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x43d0
jmp 0x396b
leaq -0x128(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3170
jmp 0x397d
leaq -0xe8(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x4270
jmp 0x3992
leaq -0x128(%rbp), %rdi
callq 0x31c0
jmp 0x39a0
leaq -0xe8(%rbp), %rdi
callq 0x31c0
jmp 0x39ae
leaq -0x108(%rbp), %rdi
callq 0x31c0
jmp 0x39bc
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
jmp 0x3ac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3a40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3a33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3a23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x31c0
jmp 0x3a21
jmp 0x3a23
leaq -0xc8(%rbp), %rdi
callq 0x31c0
jmp 0x3a31
jmp 0x3a33
leaq -0x70(%rbp), %rdi
callq 0x31c0
jmp 0x3a3e
jmp 0x3a40
leaq -0x71(%rbp), %rdi
callq 0x3330
jmp 0x3af6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3ae9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3aa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x31c0
jmp 0x3aa1
jmp 0x3aa3
leaq -0xe8(%rbp), %rdi
callq 0x31c0
jmp 0x3ab1
jmp 0x3ab3
leaq -0x108(%rbp), %rdi
callq 0x31c0
jmp 0x3ac1
jmp 0x3ae9
leaq -0x30(%rbp), %rdi
callq 0x31c0
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3af6
leaq -0x50(%rbp), %rdi
callq 0x31c0
jmp 0x3af4
jmp 0x3af6
leaq -0x30(%rbp), %rdi
callq 0x31c0
jmp 0x3b01
jmp 0x3b03
movq -0x80(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopw %cs:(%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: get_working_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string get_working_directory(string base_path)
{
    for(size_t i = base_path.length() - 1; i > 0; i--)
    {
        if(base_path[i] == '/'){
            base_path = base_path.substr(0, i);
            break;
        }
    }
    return base_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x33f0
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x423b
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3500
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x422b
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3300
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3040
jmp 0x4207
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x423b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x4229
jmp 0x4252
jmp 0x422d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x41c3
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x3170
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopw %cs:(%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: eval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void eval(string source, string base_path)
{
    vector<pair<bool, string> > tokens = tokenize(source);
    for(size_t i = 0; i < tokens.size(); ++i){
        if(tokens[i].first)
            execute_string(tokens[i].second, base_path);
        else
            stack_push(tokens[i].second, false, true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d20
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xad60
movq %rax, -0x70(%rbp)
jmp 0x42b5
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
cmpq %rcx, %rax
jae 0x4398
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xad90
movq %rax, -0x80(%rbp)
jmp 0x42d9
movq -0x80(%rbp), %rax
testb $0x1, (%rax)
je 0x4321
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xad90
movq %rax, -0x88(%rbp)
jmp 0x42f8
movq -0x68(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x5c20
jmp 0x430e
jmp 0x4385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x43aa
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xad90
movq %rax, -0x90(%rbp)
jmp 0x4337
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x434d
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x52a0
jmp 0x435f
leaq -0x60(%rbp), %rdi
callq 0x31c0
jmp 0x436a
jmp 0x4385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31c0
jmp 0x4383
jmp 0x43aa
jmp 0x4387
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x429e
leaq -0x28(%rbp), %rdi
callq 0xa9f0
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xa9f0
jmp 0x43b5
jmp 0x43b7
movq -0x38(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopl (%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: expand_home(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string expand_home(string filename)
{
    string newPath = "";
    string homeDir = exec("echo $HOME");
    trim(homeDir);
    for(size_t i = 0; i < filename.length(); ++i)
        if(i == 0 && filename[i] == '~' && filename[i+1] == '/')
            newPath += homeDir;
        else
            newPath += filename[i];
    return newPath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xbc05(%rip), %rsi      # 0x103c7
callq 0x33a0
jmp 0x47c9
leaq -0x12(%rbp), %rdi
callq 0x3330
leaq 0xbb42(%rip), %rsi      # 0x1031b
leaq -0x48(%rbp), %rdi
callq 0x4bf0
jmp 0x47e4
leaq -0x48(%rbp), %rdi
callq 0x3710
jmp 0x47ef
movq $0x0, -0x50(%rbp)
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x33f0
movq %rax, -0x78(%rbp)
jmp 0x480e
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jae 0x490a
cmpq $0x0, -0x50(%rbp)
jne 0x48ca
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3500
movq %rax, -0x88(%rbp)
jmp 0x4840
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x48ca
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3500
movq %rax, -0x90(%rbp)
jmp 0x4868
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x48ca
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3370
jmp 0x4886
jmp 0x48f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3330
jmp 0x4946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31c0
jmp 0x4921
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3500
movq %rax, -0x98(%rbp)
jmp 0x48e0
movq -0x60(%rbp), %rdi
movq -0x98(%rbp), %rax
movsbl (%rax), %esi
callq 0x31d0
jmp 0x48f5
jmp 0x48f7
jmp 0x48f9
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x47f7
movb $0x1, -0x11(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31c0
jmp 0x4919
testb $0x1, -0x11(%rbp)
jne 0x492c
jmp 0x4923
jmp 0x4939
movq -0x60(%rbp), %rdi
callq 0x31c0
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x31c0
jmp 0x4944
jmp 0x4946
movq -0x20(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopw (%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: display_version(bool)
void display_version(bool exit)
{
    cout << endl;
    cout << "  This is Polaris version " << VERSION << endl;
    cout << "  Copyright 2020, Martin del Rio (www.lartu.net)." << endl;
    cout << endl;
    if (exit) polaris_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq 0x11639(%rip), %rdi     # 0x15fd0
movq 0x11622(%rip), %rsi     # 0x15fc0
callq 0x3320
movq 0x11626(%rip), %rdi     # 0x15fd0
leaq 0xb75d(%rip), %rsi      # 0x1010e
callq 0x32e0
movq %rax, %rdi
leaq 0xb769(%rip), %rsi      # 0x10129
callq 0x32e0
movq %rax, %rdi
movq 0x115f1(%rip), %rsi     # 0x15fc0
callq 0x3320
movq 0x115f5(%rip), %rdi     # 0x15fd0
leaq 0xb74b(%rip), %rsi      # 0x1012d
callq 0x32e0
movq %rax, %rdi
movq 0x115cf(%rip), %rsi     # 0x15fc0
callq 0x3320
movq 0x115d3(%rip), %rdi     # 0x15fd0
movq 0x115bc(%rip), %rsi     # 0x15fc0
callq 0x3320
testb $0x1, -0x1(%rbp)
je 0x4a16
xorl %edi, %edi
callq 0x4960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: display_help()
void display_help()
{
    puts("");
    puts(" Usage:");
    puts("   polaris <source file> [<switch>...]");
    puts(" Switches:");
    puts("   -v              Display Polaris version information.");
    puts("   -h              Display this help.");
    puts("   -p              Show push and pops during execution.");
    puts("");
    puts(" Complete documentation for Polaris should be found on this");
    puts(" system using the 'man polaris' command. If you have access");
    puts(" to the internet, the documentation can also be found online");
    puts(" at www.lartu.net/languages/polaris.");
    puts("");
    polaris_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb99c(%rip), %rdi      # 0x103c7
callq 0x3410
leaq 0xb728(%rip), %rdi      # 0x1015f
callq 0x3410
leaq 0xb724(%rip), %rdi      # 0x10167
callq 0x3410
leaq 0xb73f(%rip), %rdi      # 0x1018e
callq 0x3410
leaq 0xb73e(%rip), %rdi      # 0x10199
callq 0x3410
leaq 0xb76a(%rip), %rdi      # 0x101d1
callq 0x3410
leaq 0xb784(%rip), %rdi      # 0x101f7
callq 0x3410
leaq 0xb948(%rip), %rdi      # 0x103c7
callq 0x3410
leaq 0xb7a4(%rip), %rdi      # 0x1022f
callq 0x3410
leaq 0xb7d4(%rip), %rdi      # 0x1026b
callq 0x3410
leaq 0xb804(%rip), %rdi      # 0x102a7
callq 0x3410
leaq 0xb835(%rip), %rdi      # 0x102e4
callq 0x3410
leaq 0xb90c(%rip), %rdi      # 0x103c7
callq 0x3410
xorl %edi, %edi
callq 0x4960
popq %rbp
retq
nopl (%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void error(string message)
{
    cout << "+---------------+" << endl;
    cout << "| Polaris Error |" << endl;
    cout << "+---------------+";
    if (message[0] != '\n') cout << endl << "The error was: ";
    cout << message << endl;
    polaris_exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x11499(%rip), %rdi     # 0x15fd0
leaq 0xb58a(%rip), %rsi      # 0x100c8
callq 0x32e0
movq %rax, %rdi
movq 0x11473(%rip), %rsi     # 0x15fc0
callq 0x3320
movq 0x11477(%rip), %rdi     # 0x15fd0
leaq 0xb57a(%rip), %rsi      # 0x100da
callq 0x32e0
movq %rax, %rdi
movq 0x11451(%rip), %rsi     # 0x15fc0
callq 0x3320
movq 0x11455(%rip), %rdi     # 0x15fd0
leaq 0xb546(%rip), %rsi      # 0x100c8
callq 0x32e0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3500
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x4bbe
movq 0x1142d(%rip), %rdi     # 0x15fd0
movq 0x11416(%rip), %rsi     # 0x15fc0
callq 0x3320
movq %rax, %rdi
leaq 0xb533(%rip), %rsi      # 0x100ec
callq 0x32e0
movq -0x10(%rbp), %rsi
movq 0x11407(%rip), %rdi     # 0x15fd0
callq 0x3290
movq %rax, %rdi
movq 0x113e8(%rip), %rsi     # 0x15fc0
callq 0x3320
movl $0x1, %edi
callq 0x4960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: exec[abi:cxx11](char const*)
string exec(const char* cmd)
{
    string result = "";
    FILE *fpipe;
    char c = 0;
    if (0 == (fpipe = (FILE*) popen(cmd, "r")))
    {
        perror("popen() failed.");
        polaris_exit(EXIT_FAILURE);
    }
    while (fread(&c, sizeof c, 1, fpipe))
        result += c;
    pclose(fpipe);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x34a0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xb79c(%rip), %rsi      # 0x103c7
callq 0x33a0
jmp 0x4c32
leaq -0x12(%rbp), %rdi
callq 0x3330
movb $0x0, -0x31(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb6bf(%rip), %rsi      # 0x10309
callq 0x3110
movq %rax, -0x58(%rbp)
jmp 0x4c55
movq -0x58(%rbp), %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x4cac
leaq 0xb6a0(%rip), %rdi      # 0x1030b
callq 0x3270
jmp 0x4c72
movl $0x1, %edi
callq 0x4960
jmp 0x4cac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3330
jmp 0x4d0e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31c0
jmp 0x4d0c
jmp 0x4cae
movq -0x30(%rbp), %rcx
leaq -0x31(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x33e0
movq %rax, -0x60(%rbp)
jmp 0x4cc9
movq -0x60(%rbp), %rax
cmpq $0x0, %rax
je 0x4ce4
movq -0x48(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x31d0
jmp 0x4ce2
jmp 0x4cae
movq -0x30(%rbp), %rdi
callq 0x33c0
jmp 0x4cef
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4d02
movq -0x48(%rbp), %rdi
callq 0x31c0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x4d0e
movq -0x20(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nop
// File: Lartu[P]polaris/src/polaris.cpp
// Function: stack_push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void stack_push(string token, bool trim_token, bool pushempty)
{
    if (trim_token) trim(token);
    if (token.length() > 0 || pushempty)
    {
        p_stack.push(token);
        if(show_pushpops) cout << "Push: '" << token << "'" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
testb $0x1, -0x9(%rbp)
je 0x52cf
movq -0x18(%rbp), %rdi
callq 0x3710
movq -0x18(%rbp), %rdi
callq 0x33f0
cmpq $0x0, %rax
ja 0x52e4
testb $0x1, -0xa(%rbp)
je 0x533c
movq -0x18(%rbp), %rsi
leaq 0x10fc1(%rip), %rdi     # 0x162b0
callq 0xaa70
testb $0x1, 0x10fae(%rip)     # 0x162a9
je 0x533a
movq 0x10ccc(%rip), %rdi     # 0x15fd0
leaq 0xb03e(%rip), %rsi      # 0x10349
callq 0x32e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
leaq 0xb029(%rip), %rsi      # 0x1034f
callq 0x32e0
movq %rax, %rdi
movq 0x10c8b(%rip), %rsi     # 0x15fc0
callq 0x3320
jmp 0x533c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: stack_pop[abi:cxx11]()
string stack_pop()
{
    string val = "";
    if(p_stack.size() == 0)
    {
        error("cannot pop from an empty stack.");
    }
    else
    {
        val = p_stack.top();
        p_stack.pop();
    }
    if(show_pushpops) cout << "Pop: '" << val << "'" << endl;
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34a0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xb03d(%rip), %rsi      # 0x103c7
callq 0x33a0
jmp 0x5391
leaq -0xa(%rbp), %rdi
callq 0x3330
leaq 0x10f0f(%rip), %rdi     # 0x162b0
callq 0xaaa0
movq %rax, -0x68(%rbp)
jmp 0x53ac
movq -0x68(%rbp), %rax
cmpq $0x0, %rax
jne 0x5461
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34a0
movq -0x70(%rbp), %rdx
leaq 0xaf7f(%rip), %rsi      # 0x10351
leaq -0x40(%rbp), %rdi
callq 0x33a0
jmp 0x53dd
leaq -0x40(%rbp), %rdi
callq 0x4b20
jmp 0x53e8
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x53f3
leaq -0x41(%rbp), %rdi
callq 0x3330
jmp 0x5492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x3330
jmp 0x552a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x551d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5453
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x5451
jmp 0x5453
leaq -0x41(%rbp), %rdi
callq 0x3330
jmp 0x551d
leaq 0x10e48(%rip), %rdi     # 0x162b0
callq 0xaac0
movq %rax, -0x78(%rbp)
jmp 0x5473
movq -0x78(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x3040
jmp 0x5482
leaq 0x10e27(%rip), %rdi     # 0x162b0
callq 0xaae0
jmp 0x5490
jmp 0x5492
testb $0x1, 0x10e10(%rip)     # 0x162a9
je 0x54fd
movq 0x10b2e(%rip), %rdi     # 0x15fd0
leaq 0xaec8(%rip), %rsi      # 0x10371
callq 0x32e0
movq %rax, -0x80(%rbp)
jmp 0x54b4
movq -0x58(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x3290
movq %rax, -0x88(%rbp)
jmp 0x54ca
movq -0x88(%rbp), %rdi
leaq 0xae77(%rip), %rsi      # 0x1034f
callq 0x32e0
movq %rax, -0x90(%rbp)
jmp 0x54e6
movq -0x90(%rbp), %rdi
movq 0x10acc(%rip), %rsi     # 0x15fc0
callq 0x3320
jmp 0x54fb
jmp 0x54fd
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x5510
movq -0x58(%rbp), %rdi
callq 0x31c0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x31c0
jmp 0x5528
jmp 0x552a
movq -0x18(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopl (%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: polaris_delay(int)
void polaris_delay(int milliseconds)
{
    struct timespec  req, rem;
    if (milliseconds <= 0L)
        return;
    req.tv_sec = milliseconds / 1000L;
    req.tv_nsec = (milliseconds % 1000L) * 1000000L;
    rem.tv_sec = 0;
    rem.tv_nsec = 0;
    nanosleep(&req, &rem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x0, %rax
jg 0x5557
jmp 0x559f
movslq -0x4(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: num_to_str[abi:cxx11](double)
string num_to_str(pnumber value)
{
    stringstream s;
    s << fixed << value;
    string str = s.str();
    trim(str);
    str.erase(str.find_last_not_of('0') + 1, string::npos);
    str.erase(str.find_last_not_of('.') + 1, string::npos);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3220
leaq -0x188(%rbp), %rdi
leaq 0x54e1(%rip), %rsi      # 0xab00
callq 0x3120
movq %rax, -0x1b0(%rbp)
jmp 0x562d
movq -0x1b0(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x34d0
jmp 0x5640
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x1a5(%rbp)
leaq -0x198(%rbp), %rsi
callq 0x32d0
jmp 0x565c
movq -0x1c0(%rbp), %rdi
callq 0x3710
jmp 0x566a
movq -0x1c0(%rbp), %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x31f0
movq %rax, -0x1c8(%rbp)
jmp 0x568b
movq -0x1c0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
incq %rsi
movq $-0x1, %rdx
callq 0x30b0
jmp 0x56aa
movq -0x1c0(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x31f0
movq %rax, -0x1d0(%rbp)
jmp 0x56cb
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rsi
incq %rsi
movq $-0x1, %rdx
callq 0x30b0
jmp 0x56ea
movb $0x1, -0x1a5(%rbp)
testb $0x1, -0x1a5(%rbp)
jne 0x5740
jmp 0x5730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x575e
movq -0x1c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0x31c0
jmp 0x575c
movq -0x1c0(%rbp), %rdi
callq 0x31c0
jmp 0x573e
jmp 0x5740
leaq -0x198(%rbp), %rdi
callq 0x3230
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
jmp 0x575e
leaq -0x198(%rbp), %rdi
callq 0x3230
jmp 0x576c
jmp 0x576e
movq -0x1a0(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopw %cs:(%rax,%rax)
// File: Lartu[P]polaris/src/polaris.cpp
// Function: get_var_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void get_var_value(string & var)
{
    if (variables.find(var) == variables.end())
        stack_push("", false, true);
    else
        stack_push(variables[var], false, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x108e6(%rip), %rdi     # 0x16300
callq 0xad00
movq %rax, -0x10(%rbp)
leaq 0x108d6(%rip), %rdi     # 0x16300
callq 0xad30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xacd0
testb $0x1, %al
jne 0x5a49
jmp 0x5ac9
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x34a0
movq -0x78(%rbp), %rdx
leaq 0xa966(%rip), %rsi      # 0x103c7
leaq -0x38(%rbp), %rdi
callq 0x33a0
jmp 0x5a6c
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x52a0
jmp 0x5a7e
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x5a89
leaq -0x39(%rbp), %rdi
callq 0x3330
jmp 0x5b1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x5abc
jmp 0x5abe
leaq -0x39(%rbp), %rdi
callq 0x3330
jmp 0x5b28
movq -0x8(%rbp), %rsi
leaq 0x1082c(%rip), %rdi     # 0x16300
callq 0xab30
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3170
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x52a0
jmp 0x5afb
leaq -0x70(%rbp), %rdi
callq 0x31c0
jmp 0x5b1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31c0
jmp 0x5b1d
jmp 0x5b28
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0xa540
nopl (%rax)
// File: nightmeng[P]net/examples/echo/server.cpp
// Function: handle_read(int, int, std::shared_ptr<socket>)
void handle_read(int ec, int t, std::shared_ptr<socket> sock){
	if(ec == 0){
		sock->sync_write(buff, t);
		sock->async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
					std::placeholders::_2, sock));
	}
	else{
		std::cerr << "async read error, errno = " << ec << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x468b
movq -0x60(%rbp), %rdi
callq 0x4dd0
movq %rax, %rdi
movslq -0x8(%rbp), %rdx
leaq 0x21c29(%rip), %rsi     # 0x26210
callq 0xb460
movq -0x60(%rbp), %rdi
callq 0x4dd0
movq -0x60(%rbp), %r8
movq %rax, -0x70(%rbp)
leaq -0x54(%rip), %rsi       # 0x45b0
movq 0x219a5(%rip), %rdx     # 0x25fb0
movq 0x219de(%rip), %rcx     # 0x25ff0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4df0
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4e40
jmp 0x462e
movq -0x70(%rbp), %rdi
leaq 0x21bd7(%rip), %rsi     # 0x26210
movl $0x800, %edx            # imm = 0x800
leaq -0x30(%rbp), %rcx
callq 0xbd30
jmp 0x4649
leaq -0x30(%rbp), %rdi
callq 0x4ee0
leaq -0x48(%rbp), %rdi
callq 0x4f00
jmp 0x46b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4ee0
leaq -0x48(%rbp), %rdi
callq 0x4f00
jmp 0x46be
movq 0x21956(%rip), %rdi     # 0x25fe8
leaq 0x12997(%rip), %rsi     # 0x17030
callq 0x4200
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x4340
movq %rax, %rdi
movq 0x218e5(%rip), %rsi     # 0x25f98
callq 0x4220
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4360
nopw (%rax,%rax)
// File: nightmeng[P]net/examples/echo/server.cpp
// Function: main
int main(){
	acceptor a;

	if(!a.bind("localhost", 1234)){
		std::cout << "bind port failed!" << std::endl;
		return -1;
	}

	if(!a.listen()){
		std::cout << "listen failed!" << std::endl;
		return -2;
	}

	a.accept([](int ec, std::shared_ptr<socket> sock){
		std::cout << "accept a connection" << std::endl;
		sock->async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
		std::placeholders::_2, sock));
	});

	char c;
	std::cin >> c;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x61c0
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4370
movq -0xa8(%rbp), %rdx
leaq 0x12942(%rip), %rsi     # 0x1704b
leaq -0x60(%rbp), %rdi
callq 0x4280
jmp 0x4714
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x4d2, %edx            # imm = 0x4D2
callq 0x62d0
movb %al, -0xa9(%rbp)
jmp 0x472e
movb -0xa9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xaa(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4160
leaq -0x61(%rbp), %rdi
callq 0x4230
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x475d
jmp 0x47e3
movq 0x2185c(%rip), %rdi     # 0x25fc0
leaq 0x128ea(%rip), %rsi     # 0x17055
callq 0x4200
movq %rax, -0xb8(%rbp)
jmp 0x4779
movq -0xb8(%rbp), %rdi
movq 0x21811(%rip), %rsi     # 0x25f98
callq 0x4220
jmp 0x478e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x78(%rbp)
jmp 0x48b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x47c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4160
leaq -0x61(%rbp), %rdi
callq 0x4230
jmp 0x48cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x48cd
leaq -0x40(%rbp), %rdi
callq 0x6380
movb %al, -0xb9(%rbp)
jmp 0x47f4
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x4841
jmp 0x4800
movq 0x217b9(%rip), %rdi     # 0x25fc0
leaq 0x12859(%rip), %rsi     # 0x17067
callq 0x4200
movq %rax, -0xc8(%rbp)
jmp 0x481c
movq -0xc8(%rbp), %rdi
movq 0x2176e(%rip), %rsi     # 0x25f98
callq 0x4220
jmp 0x4831
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl $0x1, -0x78(%rbp)
jmp 0x48b8
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x99(%rbp), %rsi
callq 0x48e0
movq -0xd0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x62a0
jmp 0x486d
leaq -0x98(%rbp), %rdi
callq 0x4f20
movq 0x21750(%rip), %rdi     # 0x25fd0
leaq -0x9a(%rbp), %rsi
callq 0x4260
jmp 0x488e
movl $0x0, -0x4(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0x48b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4f20
jmp 0x48cd
leaq -0x40(%rbp), %rdi
callq 0x6230
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x6230
movq -0x70(%rbp), %rdi
callq 0x4360
nop
// File: nightmeng[P]net/src/acceptor.cpp
// Function: acceptor::bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short)
bool acceptor::bind(const std::string &ip, unsigned short port){
	struct hostent *hostent = gethostbyname(ip.c_str());
	if(nullptr == hostent){
		return false;
	}
	struct sockaddr_in local;
	bzero(&local, sizeof(struct sockaddr_in));
	local.sin_family = AF_INET;
	local.sin_port = htons(port);
	local.sin_addr = *(reinterpret_cast<struct in_addr*>(hostent->h_addr));
	return -1 != ::bind(sock, reinterpret_cast<struct sockaddr *>(&local), sizeof(local));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0x4250
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x6312
movb $0x0, -0x1(%rbp)
jmp 0x636c
leaq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x4350
movw $0x2, -0x38(%rbp)
movzwl -0x1a(%rbp), %edi
callq 0x4040
movw %ax, %cx
movq -0x40(%rbp), %rax
movw %cx, -0x36(%rbp)
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, -0x34(%rbp)
movl 0x8(%rax), %edi
leaq -0x38(%rbp), %rsi
movl $0x10, %edx
callq 0x4060
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nightmeng[P]net/./include/net/singleton.h
// Function: singleton<scheduler>::instance()
static singleton &instance(){
			if(nullptr == _instance){
				static std::mutex mutex;
				std::lock_guard<std::mutex> locker(mutex);
				if(nullptr == _instance){
					_instance = std::shared_ptr<singleton>(new singleton);
				}
			}
			return *_instance;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq 0x200f5(%rip), %rsi     # 0x26a18
callq 0x7300
testb $0x1, %al
jne 0x6931
jmp 0x69d7
leaq -0x8(%rbp), %rdi
leaq 0x200f4(%rip), %rsi     # 0x26a30
callq 0x7330
xorl %eax, %eax
movl %eax, %edi
leaq 0x200cc(%rip), %rsi     # 0x26a18
callq 0x7300
testb $0x1, %al
jne 0x6957
jmp 0x69c1
movl $0x18, %edi
callq 0x4210
movq %rax, -0x30(%rbp)
jmp 0x6967
movq -0x30(%rbp), %rdi
callq 0x7360
jmp 0x6972
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x7380
jmp 0x6981
leaq 0x20090(%rip), %rdi     # 0x26a18
leaq -0x18(%rbp), %rsi
callq 0x73b0
leaq -0x18(%rbp), %rdi
callq 0x6d10
jmp 0x69c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x69cc
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x41f0
jmp 0x69cc
leaq -0x8(%rbp), %rdi
callq 0x73e0
jmp 0x69d7
leaq -0x8(%rbp), %rdi
callq 0x73e0
jmp 0x69e9
leaq 0x2003a(%rip), %rdi     # 0x26a18
callq 0x7410
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nightmeng[P]net/src/scheduler.cpp
// Function: scheduler::arrange(std::function<void ()>)
bool scheduler::arrange(std::function<void()> proc){
	for(auto i = 0; i != workers.size(); ++i){
		if(workers[i]->task_once(proc)){
			workers[i]->active();
			return true;
		}
	}

	if(workers.size() < 60000){
		std::shared_ptr<worker> w(new worker());
		w->task_once(proc);
		w->active();
		workers.push_back(w);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x88(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x90e0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
je 0x8f2f
movq -0x88(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9100
movq %rax, %rdi
callq 0x9120
movq -0x90(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9140
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x14470
movb %al, -0x99(%rbp)
jmp 0x8ec7
leaq -0x40(%rbp), %rdi
callq 0x6b50
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x8edc
jmp 0x8f1f
movq -0x88(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9100
movq %rax, %rdi
callq 0x9120
movq %rax, %rdi
callq 0x144e0
movb $0x1, -0x1(%rbp)
jmp 0x903c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6b50
jmp 0x904a
jmp 0x8f21
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8e4c
movq -0x88(%rbp), %rdi
callq 0x90e0
cmpq $0xea60, %rax           # imm = 0xEA60
jae 0x9038
movl $0x88, %edi
callq 0x4210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x14110
jmp 0x8f65
movq -0xb8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x91f0
movq -0xc8(%rbp), %rdi
callq 0x9120
movq -0x90(%rbp), %rsi
movq %rax, -0xc0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9140
jmp 0x8fa1
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x14470
jmp 0x8fb3
leaq -0x80(%rbp), %rdi
callq 0x6b50
leaq -0x60(%rbp), %rdi
callq 0x9120
movq %rax, %rdi
callq 0x144e0
jmp 0x8fcf
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9220
jmp 0x8fe1
movb $0x1, -0x1(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9290
jmp 0x903c
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x41f0
jmp 0x904a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x902d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6b50
leaq -0x60(%rbp), %rdi
callq 0x9290
jmp 0x904a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::job(bool)
void socket::job(bool is_read){
	std::mutex *mutex = nullptr;
	std::list<std::function<void()>> *requests = nullptr;

	switch(connect_status){
		case CONNECTING:
			mutex = &conn_mutex;
			requests = &conn_request;
			break;
		case CONNECTED:
			if(is_read){
				mutex = &rd_mutex;
				requests = &rd_request;
			}
			else{
				mutex = &wr_mutex;
				requests = &wr_request;
			}
			break;
		default:
			return;
	}

	std::function<void()> callback;
	{
		std::lock_guard<std::mutex> locker(*mutex);
		if(requests->empty()){
			return;
		}
		callback = requests->front();
		requests->pop_front();
		if(nullptr == callback)
			return;
	}
	callback();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl 0x1f4(%rax), %eax
movl %eax, -0x5c(%rbp)
subl $0x1, %eax
je 0xa4d6
jmp 0xa4cc
movl -0x5c(%rbp), %eax
subl $0x2, %eax
je 0xa4f4
jmp 0xa536
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x170, %rcx            # imm = 0x170
movq %rcx, -0x18(%rbp)
addq $0x1c8, %rax            # imm = 0x1C8
movq %rax, -0x20(%rbp)
jmp 0xa53b
testb $0x1, -0x9(%rbp)
je 0xa518
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x120, %rcx            # imm = 0x120
movq %rcx, -0x18(%rbp)
addq $0x198, %rax            # imm = 0x198
movq %rax, -0x20(%rbp)
jmp 0xa534
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x148, %rcx            # imm = 0x148
movq %rcx, -0x18(%rbp)
addq $0x1b0, %rax            # imm = 0x1B0
movq %rax, -0x20(%rbp)
jmp 0xa53b
jmp 0xa603
leaq -0x40(%rbp), %rdi
callq 0xcff0
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7330
jmp 0xa553
movq -0x20(%rbp), %rdi
callq 0xd030
testb $0x1, %al
jne 0xa562
jmp 0xa57c
movl $0x1, -0x58(%rbp)
jmp 0xa5d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xa609
movq -0x20(%rbp), %rdi
callq 0xd050
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xd080
jmp 0xa593
movq -0x20(%rbp), %rdi
callq 0xd0d0
xorl %eax, %eax
movl %eax, %edi
leaq -0x40(%rbp), %rsi
callq 0xd100
testb $0x1, %al
jne 0xa5af
jmp 0xa5cf
movl $0x1, -0x58(%rbp)
jmp 0xa5d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x73e0
jmp 0xa609
movl $0x0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x73e0
movl -0x58(%rbp), %eax
testl %eax, %eax
jne 0xa5fa
jmp 0xa5e8
leaq -0x40(%rbp), %rdi
callq 0xd130
jmp 0xa5f3
movl $0x0, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6b50
addq $0x70, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x6b50
movq -0x50(%rbp), %rdi
callq 0x4360
nopl (%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::update_addr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short)
bool socket::update_addr(const std::string &host, unsigned short port){
	struct hostent *hostent = gethostbyname(host.c_str());
	if(nullptr == hostent){
		return false;
	}
	if(nullptr == addr){
		addr = std::shared_ptr<struct sockaddr_in>(new struct sockaddr_in());
	}
	bzero(addr.get(), sizeof(struct sockaddr_in));

	addr->sin_family = AF_INET;
	addr->sin_port = htons(port);
	addr->sin_addr = *(reinterpret_cast<struct in_addr*>(hostent->h_addr));

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0x4250
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0xaa75
movb $0x0, -0x1(%rbp)
jmp 0xab59
movq -0x40(%rbp), %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
xorl %eax, %eax
movl %eax, %edi
callq 0xc430
testb $0x1, %al
jne 0xaa8f
jmp 0xaad6
movl $0x10, %edi
callq 0x4210
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x4140
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x68c0
movq -0x40(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
leaq -0x38(%rbp), %rsi
callq 0xc460
leaq -0x38(%rbp), %rdi
callq 0x6ba0
movq -0x40(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x68f0
movq %rax, %rdi
movl $0x10, %esi
callq 0x4350
movq -0x40(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0xc490
movw $0x2, (%rax)
movzwl -0x1a(%rbp), %edi
callq 0x4040
movq -0x40(%rbp), %rdi
movw %ax, -0x52(%rbp)
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0xc490
movw -0x52(%rbp), %cx
movq -0x40(%rbp), %rdi
movw %cx, 0x2(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0xc490
movq -0x50(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::sync_conn_action(std::condition_variable&, bool&)
void socket::sync_conn_action(std::condition_variable &cv, bool &processed){
	int error;
	socklen_t len = sizeof(error);
	if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) < 0){
		return;
	}
	connect_status = (0 == error)?CONNECTED:CONNECTERR;
	processed = true;
	wrable = true;
	connect_notify.notify_all();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x4, -0x20(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x4180
cmpl $0x0, %eax
jge 0xaee4
jmp 0xaf1c
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
movl $0x3, %eax
movl $0x2, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, 0x1f4(%rdi)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, 0x1f1(%rdi)
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x4320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::async_conn_action(std::function<void (int)>)
void socket::async_conn_action(ccallback ccb){
	int error;
	socklen_t len = sizeof(error);
	if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) < 0){
		return;
	}
	connect_status = (0 == error)?CONNECTED:CONNECTERR;
	wrable = true;
	singleton<scheduler>::instance()->arrange(std::bind(ccb, error));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x4, -0x18(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
callq 0x4180
cmpl $0x0, %eax
jge 0xb39a
jmp 0xb41b
movq -0x78(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl $0x3, %ecx
sbbl $0x0, %ecx
movl %ecx, 0x1f4(%rax)
movb $0x1, 0x1f1(%rax)
callq 0x6910
movq %rax, %rdi
callq 0x6a00
movq -0x80(%rbp), %rsi
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x14(%rbp), %rdx
callq 0xc7c0
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc800
jmp 0xb3f7
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e20
jmp 0xb409
leaq -0x38(%rbp), %rdi
callq 0x6b50
leaq -0x60(%rbp), %rdi
callq 0xc8a0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xb447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6b50
leaq -0x60(%rbp), %rdi
callq 0xc8a0
movq -0x68(%rbp), %rdi
callq 0x4360
nopl (%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::sync_write(void const*, unsigned long)
int socket::sync_write(const void *buff, size_t length){
	int transfered = 0;
	std::mutex sync_mutex;
	std::unique_lock<std::mutex> locker(sync_mutex);
	bool processed = false;
	std::condition_variable cv;
	{
		std::lock_guard<std::mutex> scope_locker(wr_mutex);
		wr_request.push_back(std::bind(&socket::sync_wr_action, this, 
					reinterpret_cast<const char*>(buff), length, std::ref(transfered),
					std::ref(cv), std::ref(processed)));
		if(wrable)
			wr_worker.active();
	}
	cv.wait(locker, [&processed]()->bool{return processed;});
	
	return transfered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0xc2d0
movq -0x158(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc4b0
movb $0x0, -0x59(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x42a0
movq -0x150(%rbp), %rsi
addq $0x148, %rsi            # imm = 0x148
leaq -0x98(%rbp), %rdi
callq 0x7330
jmp 0xb4d5
movq -0x150(%rbp), %rax
movq %rax, %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq %rcx, -0x160(%rbp)
leaq 0x1dc(%rip), %rcx       # 0xb6d0
movq %rcx, -0x118(%rbp)
movq $0x0, -0x110(%rbp)
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xc970
movq %rax, -0x130(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc580
movq %rax, -0x138(%rbp)
leaq -0x59(%rbp), %rdi
callq 0xc5b0
movq %rax, -0x140(%rbp)
movq %rsp, %rax
leaq -0x140(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x138(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x108(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq -0x128(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x130(%rbp), %r9
callq 0xc900
jmp 0xb591
leaq -0xc8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xc9a0
jmp 0xb5a6
movq -0x160(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xc4f0
jmp 0xb5bb
leaq -0xc8(%rbp), %rdi
callq 0x6b50
movq -0x150(%rbp), %rax
testb $0x1, 0x1f1(%rax)
je 0xb639
movq -0x150(%rbp), %rdi
addq $0x98, %rdi
callq 0x144e0
jmp 0xb5ec
jmp 0xb639
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xb6a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xb696
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x6b50
jmp 0xb696
leaq -0x98(%rbp), %rdi
callq 0x73e0
leaq -0x59(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb720
jmp 0xb669
movl -0x1c(%rbp), %eax
movl %eax, -0x164(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4380
leaq -0x58(%rbp), %rdi
callq 0xc680
movl -0x164(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x73e0
leaq -0x90(%rbp), %rdi
callq 0x4380
leaq -0x58(%rbp), %rdi
callq 0xc680
movq -0xa0(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)