LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Lartu[P]polaris/src/polaris.cpp
// Function: check_args[abi:cxx11](int, char**)
string check_args(int argc, char** argv)
{
    string filename = "";
    if (argc > 1)
    {
        for (unsigned int i = 1; i < argc; ++i)
        {
            string argument = argv[i];
            if (argument == "-v") display_version(true);
            else if (argument == "-h") display_help();
            else if (argument == "-p") show_pushpops = true;
            else
            {
                filename = argument;
                if (i < argc - 1)
                {
                    warning("some switches after the filename have been ignored.");
                    //TODO these commands should be pushed to the stack.
                }
            }
        }
    }
    if (filename == "")
        error("\nUsage: polaris <file>\nRun polaris -h for more information");
    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movl %esi, %r15d
leaq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, (%rdi)
leaq 0x594e(%rip), %rdx      # 0x9378
movq %rdi, -0x38(%rbp)
movq %rdx, %rsi
callq 0x7da8
cmpl $0x2, %r15d
jl 0x3b29
leal -0x1(%r15), %eax
movq %rax, -0x48(%rbp)
movl %r15d, %ebx
movl $0x1, %r12d
leaq -0x88(%rbp), %r15
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x3120
movq %r15, %rdi
leaq 0x560e(%rip), %rsi      # 0x9080
callq 0x30d0
testl %eax, %eax
je 0x3af5
movq %r15, %rdi
leaq 0x55fe(%rip), %rsi      # 0x9083
callq 0x30d0
testl %eax, %eax
je 0x3b53
movq %r15, %rdi
leaq 0x55ea(%rip), %rsi      # 0x9086
callq 0x30d0
testl %eax, %eax
je 0x3b01
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x3170
cmpq -0x48(%rbp), %r12
jae 0x3b08
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %r13
movq %r13, %rdi
leaq 0x55bc(%rip), %rsi      # 0x9089
leaq 0x55e8(%rip), %rdx      # 0x90bc
callq 0x7da8
movq %r13, %rdi
callq 0x4455
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3b08
callq 0x3280
jmp 0x3b08
movl $0x1, %edi
callq 0x42bc
jmp 0x3b08
movb $0x1, 0x9751(%rip)      # 0xd259
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3b1d
callq 0x3280
incq %r12
cmpq %r12, %rbx
jne 0x3a58
leaq 0x5848(%rip), %rsi      # 0x9378
movq -0x38(%rbp), %rdi
callq 0x30d0
testl %eax, %eax
je 0x3b58
movq -0x38(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x43b4
leaq -0x98(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x5553(%rip), %rsi      # 0x90bd
leaq 0x5586(%rip), %rdx      # 0x90f7
leaq -0xa8(%rbp), %rdi
callq 0x7da8
leaq -0xa8(%rbp), %rdi
callq 0x44b7
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x3bcf
jmp 0x3bd4
jmp 0x3bb7
jmp 0x3bb7
jmp 0x3bbc
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3bbf
callq 0x3280
jmp 0x3bbf
movq %rax, %r14
jmp 0x3bd4
movq %rax, %r14
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3bd4
callq 0x3280
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x3be6
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/Lartu[P]polaris/src/polaris.cpp
// Function: join_paths(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string join_paths(string base_path, string new_path)
{
    string joined_path = "";
    if(new_path[0] == '/') //Absolute Path
            joined_path = new_path;
    else if(new_path[0] == '~' && new_path[1] == '/') //Home Path
        joined_path = expand_home(new_path);
    else // Relative path
        joined_path = base_path + "/" + new_path;
    return joined_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x5762(%rip), %rdx      # 0x9378
movq %rdx, %rsi
callq 0x7da8
movq (%r14), %rsi
movzbl (%rsi), %eax
cmpl $0x7e, %eax
je 0x3c3e
cmpl $0x2f, %eax
jne 0x3c9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
jmp 0x3d02
cmpb $0x2f, 0x1(%rsi)
jne 0x3c9b
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x7e42
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x41d4
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3170
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c8d
callq 0x3280
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x3cfd
jmp 0x3d02
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7e42
leaq 0x5738(%rip), %rsi      # 0x93f5
leaq -0x68(%rbp), %rdi
callq 0x3460
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %r14, %rdx
callq 0x7a3c
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3170
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cf4
callq 0x3280
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3d02
callq 0x3280
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d2e
callq 0x3280
jmp 0x3d2e
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x3d65
jmp 0x3d6f
jmp 0x3d6c
jmp 0x3d6c
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d5c
callq 0x3280
jmp 0x3d5c
jmp 0x3d59
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3d6f
callq 0x3280
jmp 0x3d6f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3d7c
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq $0x1, %rax
je 0x3de0
movq (%r14), %rdx
leaq -0x1(%rax), %rcx
cmpb $0x2f, -0x1(%rdx,%rax)
movq %rcx, %rax
jne 0x3d9b
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x32d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3170
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3de0
callq 0x3280
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7e42
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e1c
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rsi
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x4663
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x3eda
movl $0x8, %r12d
leaq -0x58(%rbp), %r15
xorl %r13d, %r13d
movabsq $-0x3333333333333333, %rbx # imm = 0xCCCCCCCCCCCCCCCD
leaq -0x68(%rbp), %r14
cmpb $0x1, -0x8(%rdi,%r12)
jne 0x3e86
addq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x50d8
jmp 0x3ebb
movq %r15, -0x68(%rbp)
movq (%rdi,%r12), %rsi
movq 0x8(%rdi,%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x7e42
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4af9
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ebb
callq 0x3280
incq %r13
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %rbx, %rax
addq $0x28, %r12
cmpq %rax, %r13
jb 0x3e70
leaq -0x48(%rbp), %rdi
callq 0x7b76
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f08
callq 0x3280
jmp 0x3f08
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7b76
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x79b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x5181(%rip), %rdx      # 0x9378
movq %rdx, %rsi
callq 0x7da8
leaq 0x5145(%rip), %rsi      # 0x934b
leaq -0x40(%rbp), %rdi
callq 0x45bc
leaq -0x40(%rbp), %rdi
callq 0x36ac
cmpq $0x0, 0x8(%r14)
je 0x4260
xorl %r12d, %r12d
testq %r12, %r12
jne 0x4247
movq (%r14), %rax
cmpb $0x7e, (%rax)
jne 0x4247
cmpb $0x2f, 0x1(%rax)
jne 0x4247
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
jmp 0x4257
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x3250
incq %r12
cmpq 0x8(%r14), %r12
jb 0x4222
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4272
callq 0x3280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4289
movq %rax, %r14
jmp 0x429e
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x429e
callq 0x3280
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x42ab
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x8d04(%rip), %r14      # 0xcfd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4e44(%rip), %rsi      # 0x913e
movl $0x1a, %edx
movq %r14, %rdi
callq 0x32f0
leaq 0x4e4b(%rip), %rsi      # 0x9159
movl $0x3, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4e14(%rip), %rsi      # 0x915d
movl $0x31, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
testl %ebx, %ebx
jne 0x43ad
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xa, %edi
callq 0x3330
leaq 0x4dc6(%rip), %rdi      # 0x918f
callq 0x3390
leaq 0x4dc2(%rip), %rdi      # 0x9197
callq 0x3390
leaq 0x4ddd(%rip), %rdi      # 0x91be
callq 0x3390
leaq 0x4ddc(%rip), %rdi      # 0x91c9
callq 0x3390
leaq 0x4e08(%rip), %rdi      # 0x9201
callq 0x3390
leaq 0x4e22(%rip), %rdi      # 0x9227
callq 0x3390
movl $0xa, %edi
callq 0x3330
leaq 0x4e44(%rip), %rdi      # 0x925f
callq 0x3390
leaq 0x4e74(%rip), %rdi      # 0x929b
callq 0x3390
leaq 0x4ea4(%rip), %rdi      # 0x92d7
callq 0x3390
leaq 0x4ed5(%rip), %rdi      # 0x9314
callq 0x3390
movl $0xa, %edi
callq 0x3330
xorl %edi, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8b05(%rip), %r14      # 0xcfd0
leaq 0x4c26(%rip), %r15      # 0x90f8
movl $0x11, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4bfa(%rip), %rsi      # 0x910a
movl $0x11, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movl $0x11, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%rbx), %rax
cmpb $0xa, (%rax)
je 0x4597
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4b92(%rip), %rsi      # 0x911c
movl $0xf, %edx
movq %rax, %rdi
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x8a2b(%rip), %rdi      # 0xcfd0
callq 0x32f0
movq %rax, %rdi
callq 0x3150
movl $0x1, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x4d99(%rip), %rdx      # 0x9378
movq %rdx, %rsi
callq 0x7da8
movb $0x0, -0x21(%rbp)
leaq 0x4d47(%rip), %rsi      # 0x9339
movq %r14, %rdi
callq 0x30f0
testq %rax, %rax
je 0x4646
movq %rax, %r14
leaq -0x21(%rbp), %r15
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3360
testq %rax, %rax
je 0x462e
movsbl -0x21(%rbp), %esi
movq %rbx, %rdi
callq 0x3250
jmp 0x4606
movq %r14, %rdi
callq 0x3340
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3480
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x465b
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0x4b12
movq %rbx, %rdi
callq 0x36ac
cmpq $0x0, 0x8(%rbx)
sete %al
xorb $0x1, %r14b
testb %r14b, %al
jne 0x4bab
leaq 0x8732(%rip), %rdi      # 0xd260
movq %rbx, %rsi
callq 0x871e
cmpb $0x1, 0x871c(%rip)      # 0xd259
jne 0x4bab
movq 0x848a(%rip), %r14      # 0xcfd0
leaq 0x482c(%rip), %rsi      # 0x9379
movl $0x7, %edx
movq %r14, %rdi
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32f0
movq %rax, %rbx
leaq 0x480c(%rip), %rsi      # 0x937f
movl $0x1, %edx
movq %rax, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x47a8(%rip), %rdx      # 0x9378
movq %rdx, %rsi
callq 0x7da8
movq 0x86c9(%rip), %rax      # 0xd2a8
movq %rax, %rdx
subq 0x869f(%rip), %rdx      # 0xd288
shrq $0x3, %rdx
cmpq $0x1, %rax
adcq $-0x1, %rdx
shlq $0x4, %rdx
movq 0x8690(%rip), %rsi      # 0xd290
movq 0x8691(%rip), %rcx      # 0xd298
movq %rsi, %rdi
subq %rcx, %rdi
sarq $0x5, %rdi
addq %rdx, %rdi
movq 0x8665(%rip), %rdx      # 0xd280
subq 0x864e(%rip), %rdx      # 0xd270
sarq $0x5, %rdx
addq %rdi, %rdx
je 0x4cd7
cmpq %rcx, %rsi
jne 0x4c3d
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rax), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x3170
leaq 0x8610(%rip), %rdi      # 0xd260
callq 0x89b8
cmpb $0x1, 0x85fd(%rip)      # 0xd259
jne 0x4cc7
movq 0x836b(%rip), %rdi      # 0xcfd0
leaq 0x4735(%rip), %rsi      # 0x93a1
movl $0x6, %edx
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x834c(%rip), %rdi      # 0xcfd0
callq 0x32f0
movq %rax, %r14
leaq 0x46ec(%rip), %rsi      # 0x937f
movl $0x1, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x469a(%rip), %rsi      # 0x9381
leaq 0x46b2(%rip), %rdx      # 0x93a0
leaq -0x40(%rbp), %rdi
callq 0x7da8
leaq -0x40(%rbp), %rdi
callq 0x44b7
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4d18
callq 0x3280
jmp 0x4d18
jmp 0x4d15
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4d25
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edi, %edi
jle 0x4d7b
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, %ecx
movabsq $0x4189374bc6a7f0, %rdx # imm = 0x4189374BC6A7F0
movq %rcx, %rax
mulq %rdx
leaq -0x20(%rbp), %rdi
movq %rdx, (%rdi)
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
subq %rax, %rcx
imulq $0xf4240, %rcx, %rax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
leaq -0x10(%rbp), %rsi
movaps %xmm0, (%rsi)
callq 0x30e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
leaq -0x190(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl -0x178(%rbp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, -0x178(%rbp,%rax)
movsd -0x18(%rbp), %xmm0
callq 0x33d0
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x33c0
movq %rbx, %rdi
callq 0x36ac
movq %rbx, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x31b0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x4e63
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x31b0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x4e63
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x469f(%rip), %rdi      # 0x9509
leaq 0x4743(%rip), %rsi      # 0x95b4
movq %rax, %rdx
xorl %eax, %eax
callq 0x3370
movq %rax, %r14
jmp 0x4e94
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4e94
callq 0x3280
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x79b0
// File: /workspace/github_cpp_makefile_star2_O1/Lartu[P]polaris/src/polaris.cpp
// Function: str_is_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool str_is_num(string & source){
    if (source == "inf") return true;
    if (source == "-inf") return true;
    bool already_found_sign = false;
    bool already_found_point = false;
    size_t numbers_before_point = 0;
    size_t numbers_after_point = 0;
    for(size_t i = 0; i < source.length(); ++i)
        if(!already_found_sign && source[i] == '-')
            already_found_sign = true;
        else if(!already_found_point && source[i] == '.')
            already_found_point = true;
        else if(
        source[i] == '0' || source[i] == '1' 
        || source[i] == '2' || source[i] == '3'
        || source[i] == '4' || source[i] == '5'
        || source[i] == '6' || source[i] == '7'
        || source[i] == '8' || source[i] == '9'
        )
        {
            already_found_sign = true;
            if(already_found_point)
                numbers_after_point++;
            else
                numbers_before_point++;
        }
        else
            return false;
    if(numbers_before_point == 0)
        return false;
    if(already_found_point && numbers_after_point == 0)
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x44e8(%rip), %rsi      # 0x93a9
callq 0x30d0
movb $0x1, %bl
testl %eax, %eax
je 0x4f5b
leaq 0x44d1(%rip), %rsi      # 0x93a8
movq %r14, %rdi
callq 0x30d0
testl %eax, %eax
je 0x4f5b
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4f59
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %ebx, %ebx
xorl %r9d, %r9d
testb $0x1, %r9b
jne 0x4f09
movb $0x1, %r8b
cmpb $0x2d, (%rcx,%rdx)
je 0x4f39
testb $0x1, %bl
jne 0x4f1b
cmpb $0x2e, (%rcx,%rdx)
jne 0x4f1b
movl %r9d, %r8d
movb $0x1, %bl
jmp 0x4f39
movb (%rcx,%rdx), %r8b
addb $-0x30, %r8b
cmpb $0x9, %r8b
ja 0x4f59
testb $0x1, %bl
je 0x4f33
incq %rsi
jmp 0x4f36
incq %rdi
movb $0x1, %r8b
incq %rdx
movl %r8d, %r9d
cmpq %rdx, %rax
jne 0x4efa
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
xorb $0x1, %bl
orb %cl, %bl
andb %al, %bl
jmp 0x4f5b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8310(%rip), %rdi      # 0xd2b0
movq %rbx, %rsi
callq 0x8db8
leaq 0x8309(%rip), %rcx      # 0xd2b8
cmpq %rcx, %rax
je 0x4ff6
leaq 0x82f5(%rip), %rdi      # 0xd2b0
movq %rbx, %rsi
callq 0x7bc6
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7e42
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4af9
movq -0x30(%rbp), %rdi
jmp 0x5027
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4373(%rip), %rdx      # 0x9378
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7da8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4af9
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x5031
callq 0x3280
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x504a
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5054
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %edi, %edi
je 0x3608
movl %edi, %ebx
movq 0xba3a(%rip), %r14      # 0xeff0
leaq 0x5a57(%rip), %rsi      # 0x9014
movl $0x1a, %edx
movq %r14, %rdi
callq 0x3230
movq %r14, %rdi
movl %ebx, %esi
callq 0x3310
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3150
movq %rdx, %r15
movq (%rdx), %rdi
movslq %esi, %rdx
leaq 0xbbe8(%rip), %rsi      # 0xf200
callq 0x5e7a
movq (%r15), %r14
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x363e
movq 0xb990(%rip), %rax      # 0xefc0
cmpb $0x0, (%rax)
je 0x363a
incl 0x8(%rbx)
jmp 0x363e
lock
incl 0x8(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movl $0x18, %edi
callq 0x3200
leaq -0xbe(%rip), %rcx       # 0x359c
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq -0x40(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x447(%rip), %rax       # 0x3aba
movq %rax, 0x18(%rcx)
leaq 0x44e(%rip), %rax       # 0x3acc
movq %rax, 0x10(%rcx)
leaq 0xbb77(%rip), %rsi      # 0xf200
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
callq 0x6640
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x36ad
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36d8
movq %rax, %r14
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x36d4
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %ebx, %ebx
jmp 0x36e3
movq %rax, %rdi
callq 0x3a3f
movq %rax, %r14
testq %rbx, %rbx
je 0x36f0
movq %rbx, %rdi
callq 0x3a4e
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq -0x88(%rbp), %rdi
callq 0x3cbc
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x590e(%rip), %rsi      # 0x902f
leaq 0x5910(%rip), %rdx      # 0x9038
leaq -0x30(%rbp), %rdi
callq 0x3c22
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4d2, %edx            # imm = 0x4D2
callq 0x3daa
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3756
callq 0x31e0
testb %bl, %bl
je 0x37c8
leaq -0x88(%rbp), %rdi
callq 0x3e28
testb %al, %al
je 0x3815
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq 0x14f(%rip), %rax       # 0x38ce
movq %rax, 0x18(%rsi)
leaq 0x298(%rip), %rax       # 0x3a22
movq %rax, 0x10(%rsi)
leaq -0x88(%rbp), %rdi
callq 0x3d8c
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x37b1
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xb820(%rip), %rdi      # 0xefd8
leaq -0x30(%rbp), %rsi
callq 0x3240
xorl %ebx, %ebx
jmp 0x3860
movq 0xb7f9(%rip), %rbx      # 0xefc8
leaq 0x5863(%rip), %rsi      # 0x9039
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0xb7c7(%rip), %rdi      # 0xefc8
callq 0x3030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x3150
jmp 0x3860
movq 0xb7ac(%rip), %rbx      # 0xefc8
leaq 0x5828(%rip), %rsi      # 0x904b
movl $0xe, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0xb77a(%rip), %rdi      # 0xefc8
callq 0x3030
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rax, %rdi
callq 0x3150
leaq -0x88(%rbp), %rdi
callq 0x3d30
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x389a
jmp 0x38b7
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x38ba
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x38ba
movq %rax, %rdi
callq 0x3a3f
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x38ba
callq 0x31e0
jmp 0x38ba
jmp 0x38b7
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3d30
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x3220
testq %rax, %rax
je 0x3e18
movq %rax, %r15
leaq -0x30(%rbp), %r12
movl $0x10, %esi
movq %r12, %rdi
callq 0x3320
movw $0x2, (%r12)
rolw $0x8, %r14w
movw %r14w, 0x2(%r12)
movq 0x18(%r15), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x4(%r12)
movl 0x8(%rbx), %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x3060
cmpl $-0x1, %eax
setne %al
jmp 0x3e1a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0xb737(%rip)      # 0xfa08
jne 0x434f
leaq 0xb746(%rip), %rdi      # 0xfa20
callq 0x32a0
testl %eax, %eax
jne 0x435f
cmpq $0x0, 0xb71d(%rip)      # 0xfa08
jne 0x4343
movl $0x18, %edi
callq 0x3200
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a80
leaq -0x18(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x4564
movaps -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x20(%rbp)
movq 0xb6ec(%rip), %rdi      # 0xfa10
movups %xmm0, 0xb6dd(%rip)     # 0xfa08
testq %rdi, %rdi
je 0x4335
callq 0x3a4e
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x4343
callq 0x3a4e
leaq 0xb6d6(%rip), %rdi      # 0xfa20
callq 0x3180
movq 0xb6b2(%rip), %rax      # 0xfa08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x3140
movq %rax, %r14
movq %rbx, %rdi
callq 0x31e0
jmp 0x4376
movq %rax, %r14
leaq 0xb6a3(%rip), %rdi      # 0xfa20
callq 0x3180
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, -0x38(%rbp)
movq (%rdi), %rax
movq %rdi, -0x30(%rbp)
cmpq %rax, 0x8(%rdi)
sete %r14b
je 0x4b4d
xorl %r13d, %r13d
leaq -0x88(%rbp), %r15
xorl %ebx, %ebx
movq (%rax,%r13), %r12
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x4cb6
movq %r12, %rdi
movq %r15, %rsi
callq 0x8266
movl %eax, %r12d
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x4b08
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
testb %r12b, %r12b
jne 0x4b31
incq %rbx
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r13
cmpq %rcx, %rbx
sete %r14b
jne 0x4ad4
jmp 0x4b4d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13), %rdi
callq 0x82aa
movb $0x1, %al
testb $0x1, %r14b
je 0x4bec
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cmpq $0xea5ff, %rax          # imm = 0xEA5FF
ja 0x4bea
movl $0x88, %edi
callq 0x3200
movq %rax, %r15
movq %rax, %rdi
callq 0x7fa4
leaq -0x40(%rbp), %r12
movq %r15, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4d62
movq -0x8(%r12), %r15
leaq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4cb6
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x8266
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x4bc2
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x48(%rbp), %rdi
callq 0x82aa
leaq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x4d1c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4be6
callq 0x3a4e
movb $0x1, %al
jmp 0x4bec
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c62
movq %rax, %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x4c2b
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x4c2b
jmp 0x4c62
movq %rax, %rbx
movq %r15, %rdi
callq 0x31e0
jmp 0x4c5a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4c5a
callq 0x3a4e
jmp 0x4c5a
jmp 0x4c62
movq %rax, %rbx
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x4c5a
leaq -0x88(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a3f
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1f4(%rdi), %eax
cmpl $0x1, %eax
je 0x5293
cmpl $0x2, %eax
jne 0x531c
testb %sil, %sil
movl $0x120, %eax            # imm = 0x120
movl $0x148, %r14d           # imm = 0x148
cmovneq %rax, %r14
movl $0x198, %eax            # imm = 0x198
movl $0x1b0, %r15d           # imm = 0x1B0
cmovneq %rax, %r15
jmp 0x529f
movl $0x1c8, %r15d           # imm = 0x1C8
movl $0x170, %r14d           # imm = 0x170
addq %rbx, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x5327
addq %r15, %rbx
movq (%rbx), %rsi
cmpq %rbx, %rsi
je 0x52fd
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
callq 0x6cb0
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x7bfc
movq -0x30(%rbp), %rbx
movq %r14, %rdi
callq 0x3180
testq %rbx, %rbx
je 0x5305
cmpq $0x0, -0x30(%rbp)
je 0x532e
leaq -0x40(%rbp), %rdi
callq *0x18(%rdi)
jmp 0x5305
movq %r14, %rdi
callq 0x3180
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x531c
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
callq 0x30e0
jmp 0x5366
movq %rax, %rbx
movq %r14, %rdi
callq 0x3180
jmp 0x5347
jmp 0x5344
movq %rax, %rbx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x535e
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a3f
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x3220
movq %rax, %r14
testq %rax, %rax
je 0x5787
cmpq $0x0, 0x1e0(%r15)
jne 0x5756
movl $0x10, %edi
callq 0x3200
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq -0x28(%rbp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x44b2
movaps -0x8(%r12), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x8(%r12)
movq 0x1e8(%r15), %rdi
movups %xmm0, 0x1e0(%r15)
testq %rdi, %rdi
je 0x5748
callq 0x3a4e
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x5756
callq 0x3a4e
movq 0x1e0(%r15), %rdi
movl $0x10, %esi
callq 0x3320
movq 0x1e0(%r15), %rax
movw $0x2, (%rax)
rolw $0x8, %bx
movw %bx, 0x2(%rax)
movq 0x18(%r14), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
testq %r14, %r14
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x18(%rbp), %r8
movl $0x4, (%r8)
movl 0x8(%rdi), %edi
leaq -0x14(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x3170
testl %eax, %eax
js 0x5a20
cmpl $0x1, -0x14(%rbp)
movl $0x3, %eax
sbbl $0x0, %eax
movl %eax, 0x1f4(%rbx)
movb $0x1, %al
movb %al, (%r14)
movb %al, 0x1f1(%rbx)
addq $0x1f8, %rbx            # imm = 0x1F8
movq %rbx, %rdi
callq 0x32f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r8
movl $0x4, (%r8)
movl 0x8(%rdi), %edi
leaq -0x1c(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x3170
testl %eax, %eax
js 0x5e23
cmpl $0x1, -0x1c(%rbp)
movl $0x3, %eax
sbbl $0x0, %eax
movl %eax, 0x1f4(%r14)
movb $0x1, 0x1f1(%r14)
callq 0x42be
movq %rax, %r14
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6fd4
movl -0x1c(%rbp), %eax
movl %eax, 0x20(%r15)
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x6b38
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x4a9e
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x5e0c
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x5e23
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e72
jmp 0x5e72
movq %rax, %rbx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x5e53
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5e53
jmp 0x5e72
movq %rax, %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x5e6a
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a3f
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
xorl %r13d, %r13d
movb %r13b, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6e2a
movb $0x1, 0x8(%rbx)
movb %r13b, -0x29(%rbp)
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x3270
leaq 0x148(%r14), %rbx
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x5fd6
leaq 0x130(%rip), %rax       # 0x6032
leaq -0x100(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x29(%rbp), %rax
movq %rax, 0x10(%rsi)
movq %r13, 0x18(%rsi)
leaq -0x30(%rbp), %rax
movq %rax, 0x20(%rsi)
movq %r12, 0x28(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x38(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x6b96
leaq 0x1b0(%r14), %rdi
leaq -0x60(%rbp), %rdx
movq %rdi, %rsi
callq 0x6ea2
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x5f67
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f1(%r14)
jne 0x5f80
addq $0x98, %r14
movq %r14, %rdi
callq 0x82aa
movq %rbx, %rdi
callq 0x3180
cmpb $0x0, -0x29(%rbp)
jne 0x5faa
leaq -0x90(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a0
cmpb $0x1, -0x29(%rbp)
jne 0x5f99
movl -0x30(%rbp), %ebx
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6ac0
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x6005
jmp 0x5ffd
movq %rax, %r14
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x6008
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6008
movq %rax, %rdi
callq 0x3a3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
jmp 0x6015
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6ac0
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/nightmeng[P]net/src/socket.cpp
// Function: socket::sync_read(void*, unsigned long)
int socket::sync_read(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 sync_cv;
	{
		std::lock_guard<std::mutex> scope_locker(rd_mutex);
		rd_request.push_back(std::bind(&socket::sync_rd_action, this, 
					reinterpret_cast<char*>(buff), length, std::ref(transfered),
					std::ref(sync_cv), std::ref(processed)));
		if(rdable)
			rd_worker.active();
	}
	sync_cv.wait(locker, [&processed]()->bool{return processed;});

	return transfered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
xorl %r13d, %r13d
movb %r13b, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6e2a
movb $0x1, 0x8(%rbx)
movb %r13b, -0x29(%rbp)
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x3270
leaq 0x120(%r14), %rbx
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x6225
leaq 0x12e(%rip), %rax       # 0x6282
leaq -0x100(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x29(%rbp), %rax
movq %rax, 0x10(%rsi)
movq %r13, 0x18(%rsi)
leaq -0x30(%rbp), %rax
movq %rax, 0x20(%rsi)
movq %r12, 0x28(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x38(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x6bf4
leaq 0x198(%r14), %rdi
leaq -0x60(%rbp), %rdx
movq %rdi, %rsi
callq 0x6ea2
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x61b9
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f0(%r14)
jne 0x61cf
addq $0x10, %r14
movq %r14, %rdi
callq 0x82aa
movq %rbx, %rdi
callq 0x3180
cmpb $0x0, -0x29(%rbp)
jne 0x61f9
leaq -0x90(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a0
cmpb $0x1, -0x29(%rbp)
jne 0x61e8
movl -0x30(%rbp), %ebx
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6ac0
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x6254
jmp 0x624c
movq %rax, %r14
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x6257
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6257
movq %rax, %rdi
callq 0x3a3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
jmp 0x6264
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6ac0
movq %r14, %rdi
callq 0x3330
nop