LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: XuhuiSun95[P]Ticket-Booking-Service/server/Server.cpp
// Function: Server::HandleRequest[abi:cxx11](int const&)
std::string Server::HandleRequest(const int &amount) {

    int left = mTickets - amount;

    if(left < 0) {
        return "Not enought ticket to sale!";
    }
    else {
        mTickets = mTickets - amount;
        return "Success!";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2c1d
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2360
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3466(%rip), %rsi      # 0x605a
callq 0x2290
jmp 0x2bfb
leaq -0x1d(%rbp), %rdi
callq 0x2230
jmp 0x2c72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x2230
jmp 0x2c7c
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rdx
movl (%rdx), %edx
subl %edx, %ecx
movl %ecx, (%rax)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2360
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x342d(%rip), %rsi      # 0x6076
callq 0x2290
jmp 0x2c50
leaq -0x2d(%rbp), %rdi
callq 0x2230
jmp 0x2c72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x2230
jmp 0x2c7c
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerInterface.cpp
// Function: ServerInterface::ServerInterface()
ServerInterface::ServerInterface() {

    std::cout << "==================================================" << std::endl;
    std::cout << "||"
              << std::setw(31) << std::right << "Server Interface" 
              << std::setw(17) << std::right << "||" << std::endl;
    std::cout << "==================================================" << std::endl;

    mQuit = false;
    mServer = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22a0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2d20
jmp 0x3cd7
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2d20
jmp 0x3cea
movq 0x62d7(%rip), %rdi      # 0x9fc8
leaq 0x240e(%rip), %rsi      # 0x6106
callq 0x21f0
movq %rax, -0x48(%rbp)
jmp 0x3d03
movq -0x48(%rbp), %rdi
movq 0x62a2(%rip), %rsi      # 0x9fb0
callq 0x2220
jmp 0x3d15
movq 0x62ac(%rip), %rdi      # 0x9fc8
leaq 0x2416(%rip), %rsi      # 0x6139
callq 0x21f0
movq %rax, -0x50(%rbp)
jmp 0x3d2e
movl $0x1f, %edi
callq 0x4d10
movl %eax, -0x54(%rbp)
jmp 0x3d3d
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2250
movq %rax, -0x60(%rbp)
jmp 0x3d55
movq -0x60(%rbp), %rdi
leaq 0xfd0(%rip), %rsi       # 0x4d30
callq 0x20c0
movq %rax, -0x68(%rbp)
jmp 0x3d6b
movq -0x68(%rbp), %rdi
leaq 0x23c6(%rip), %rsi      # 0x613c
callq 0x21f0
movq %rax, -0x70(%rbp)
jmp 0x3d81
movl $0x11, %edi
callq 0x4d10
movl %eax, -0x74(%rbp)
jmp 0x3d90
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2250
movq %rax, -0x80(%rbp)
jmp 0x3da8
movq -0x80(%rbp), %rdi
leaq 0xf7d(%rip), %rsi       # 0x4d30
callq 0x20c0
movq %rax, -0x88(%rbp)
jmp 0x3dc1
movq -0x88(%rbp), %rdi
leaq 0x236a(%rip), %rsi      # 0x6139
callq 0x21f0
movq %rax, -0x90(%rbp)
jmp 0x3ddd
movq -0x90(%rbp), %rdi
movq 0x61c5(%rip), %rsi      # 0x9fb0
callq 0x2220
jmp 0x3df2
movq 0x61cf(%rip), %rdi      # 0x9fc8
leaq 0x2306(%rip), %rsi      # 0x6106
callq 0x21f0
movq %rax, -0x98(%rbp)
jmp 0x3e0e
movq -0x98(%rbp), %rdi
movq 0x6194(%rip), %rsi      # 0x9fb0
callq 0x2220
jmp 0x3e23
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x3e71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x3e68
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2db0
movq -0x28(%rbp), %rdi
callq 0x2db0
movq -0x38(%rbp), %rdi
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerInterface.cpp
// Function: ServerInterface::Run()
void ServerInterface::Run() {

    int opt = -1;

    while(!mQuit) {

        while(mServerName.empty())
            Init();

        OptionMessage();
        std::cin >> opt;
        if(!std::cin.good()) {

            std::cout << "Unknow option! Please enter again." << std::endl;
            std::cin.clear();
            std::cin.ignore(INT_MAX, '\n');
            continue;
        }

        switch(opt) {
            case 1:
                PrintStatus();
                break;
            case 2:
                Host();
                break;
            case 3:
                mQuit = true;
                break;
            default:
                std::cout << "Unknow option! Please enter again." << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movb (%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3efc
jmp 0x4013
jmp 0x3efe
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2300
testb $0x1, %al
jne 0x3f11
jmp 0x3f1c
movq -0x18(%rbp), %rdi
callq 0x4020
jmp 0x3efe
movq -0x18(%rbp), %rdi
callq 0x45e0
movq 0x60b4(%rip), %rdi      # 0x9fe0
leaq -0xc(%rbp), %rsi
callq 0x2140
movq 0x60a4(%rip), %rax      # 0x9fe0
movq (%rax), %rax
movq 0x609a(%rip), %rdi      # 0x9fe0
addq -0x18(%rax), %rdi
callq 0x2320
testb $0x1, %al
jne 0x3fac
movq 0x606e(%rip), %rdi      # 0x9fc8
leaq 0x21ec(%rip), %rsi      # 0x614d
callq 0x21f0
movq %rax, %rdi
movq 0x6040(%rip), %rsi      # 0x9fb0
callq 0x2220
movq 0x6064(%rip), %rax      # 0x9fe0
movq (%rax), %rax
movq 0x605a(%rip), %rdi      # 0x9fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2310
movq 0x6048(%rip), %rdi      # 0x9fe0
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0xa, %edx
callq 0x2160
jmp 0x3eeb
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x3fcd
jmp 0x3fb9
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x3fd8
jmp 0x3fc3
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x3fe3
jmp 0x3fec
movq -0x18(%rbp), %rdi
callq 0x4680
jmp 0x400e
movq -0x18(%rbp), %rdi
callq 0x4c20
jmp 0x400e
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x400e
movq 0x5fd5(%rip), %rdi      # 0x9fc8
leaq 0x2153(%rip), %rsi      # 0x614d
callq 0x21f0
movq %rax, %rdi
movq 0x5fa7(%rip), %rsi      # 0x9fb0
callq 0x2220
jmp 0x3eeb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerInterface.cpp
// Function: ServerInterface::OptionMessage()
void ServerInterface::OptionMessage() {

    std::cout << std::endl;
    std::cout << "1. Server Status" << std::endl;
    std::cout << "2. Host Server" << std::endl;
    std::cout << "3. Quit" << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x59d5(%rip), %rdi      # 0x9fc8
movq 0x59b6(%rip), %rsi      # 0x9fb0
callq 0x2220
movq 0x59c2(%rip), %rdi      # 0x9fc8
leaq 0x1c1e(%rip), %rsi      # 0x622b
callq 0x21f0
movq %rax, %rdi
movq 0x5994(%rip), %rsi      # 0x9fb0
callq 0x2220
movq 0x59a0(%rip), %rdi      # 0x9fc8
leaq 0x1c0d(%rip), %rsi      # 0x623c
callq 0x21f0
movq %rax, %rdi
movq 0x5972(%rip), %rsi      # 0x9fb0
callq 0x2220
movq 0x597e(%rip), %rdi      # 0x9fc8
leaq 0x1bfa(%rip), %rsi      # 0x624b
callq 0x21f0
movq %rax, %rdi
movq 0x5950(%rip), %rsi      # 0x9fb0
callq 0x2220
movq 0x595c(%rip), %rdi      # 0x9fc8
movq 0x593d(%rip), %rsi      # 0x9fb0
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nop
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerInterface.cpp
// Function: ServerInterface::Host()
void ServerInterface::Host() {

    std::cout << "Hosting..." << std::endl;
    mServer = true;
    std::cout << std::endl;

    Server *server = new Server(mServerInfo, mPairInfo);

    server->Run(mServerName);

    delete server;
    mServer = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x538d(%rip), %rdi      # 0x9fc8
movq %rdi, -0x40(%rbp)
leaq 0x1697(%rip), %rsi      # 0x62dd
callq 0x21f0
movq %rax, %rdi
movq 0x535b(%rip), %rsi      # 0x9fb0
movq %rsi, -0x38(%rbp)
callq 0x2220
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movb $0x1, 0x1(%rax)
callq 0x2220
movl $0x88, %edi
callq 0x2200
movq -0x30(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdx, %rsi
addq $0x28, %rsi
addq $0x50, %rdx
callq 0x25c0
jmp 0x4c9d
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x2710
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4cd6
movq -0x48(%rbp), %rdi
callq 0x26b0
movq -0x48(%rbp), %rdi
callq 0x21e0
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21e0
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerSocket.cpp
// Function: ServerSocket::Accept()
int ServerSocket::Accept() {

    int addrlen = sizeof(mAddress);
    int new_socket;

    if((new_socket = accept(mSockfd, (struct sockaddr *)&mAddress, (socklen_t*)&addrlen))<0) {
        std::cout << "Accept Failed" << std::endl;
        return -1;
    }

    return new_socket;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x10, -0x14(%rbp)
movl 0x4(%rsi), %edi
addq $0xc, %rsi
leaq -0x14(%rbp), %rdx
callq 0x20b0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0x54ba
movq 0x4b32(%rip), %rdi      # 0x9fc8
leaq 0xf91(%rip), %rsi       # 0x642e
callq 0x21f0
movq %rax, %rdi
movq 0x4b04(%rip), %rsi      # 0x9fb0
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54c0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerSocket.cpp
// Function: ServerSocket::GetMessage[abi:cxx11](int const&)
std::string ServerSocket::GetMessage(const int &sock) {

    mValread = read(sock, buffer, 1024);
    std::string message = buffer;
    memset(buffer, 0, sizeof(buffer));
    
    return message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
addq $0x1c, %rsi
movq %rsi, -0x40(%rbp)
movl $0x400, %edx            # imm = 0x400
callq 0x22b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2360
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2290
jmp 0x553d
leaq -0x1a(%rbp), %rdi
callq 0x2230
movq -0x50(%rbp), %rdi
addq $0x1c, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2120
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5586
jmp 0x557d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x2230
jmp 0x5590
movq -0x48(%rbp), %rdi
callq 0x2150
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerSocket.cpp
// Function: ServerSocket::SendMessage(int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ServerSocket::SendMessage(const int &sock, const std::string &message) {

    //  Delay 5 second to simulate the time for message passing
    std::this_thread::sleep_for(std::chrono::seconds(5));
    send(sock, message.c_str(), message.length(), 0);

    close(sock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x5, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x57e0
leaq -0x20(%rbp), %rdi
callq 0x5730
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22e0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x2380
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/ServerSocket.cpp
// Function: ServerSocket::ForwardTicket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string ServerSocket::ForwardTicket(const std::string &message) {

    //  Delay 5 second to simulate the time for message passing
    std::this_thread::sleep_for(std::chrono::seconds(5));
    send(mSockfd, message.c_str(), message.length(), 0);

    mValread = read(mSockfd, buffer, 1024);

    std::string reply = buffer;

    return reply;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x5, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x57e0
movq -0x70(%rbp), %rdi
callq 0x5730
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22e0
movl -0x64(%rbp), %edi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2110
movq -0x58(%rbp), %rsi
movl 0x4(%rsi), %edi
addq $0x1c, %rsi
movq %rsi, -0x48(%rbp)
movl $0x400, %edx            # imm = 0x400
callq 0x22b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x0, -0x25(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2360
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2290
jmp 0x56e3
leaq -0x26(%rbp), %rdi
callq 0x2230
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x5718
jmp 0x570f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x2230
jmp 0x5725
movq -0x50(%rbp), %rdi
callq 0x2150
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2350
nop
// File: XuhuiSun95[P]Ticket-Booking-Service/server/main.cpp
// Function: main
int main(int argc, char* argv[]) {

    ServerInterface* server = new ServerInterface();

    server->Run();

    delete server;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x78, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x3ca0
jmp 0x5ad1
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3ed0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5b02
movq -0x38(%rbp), %rdi
callq 0x3e90
movq -0x38(%rbp), %rdi
callq 0x21e0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21e0
movq -0x20(%rbp), %rdi
callq 0x2350
// File: jo-qzy[P]MyJson/test.cpp
// Function: main
int main() {
    test_parse();
    printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
    test_convert();
    return main_ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x41e0
movl 0x2905e(%rip), %esi     # 0x2d1f8
movl 0x29054(%rip), %edx     # 0x2d1f4
cvtsi2sdl 0x29050(%rip), %xmm0 # 0x2d1f8
movsd 0x20e80(%rip), %xmm1    # 0x25030
mulsd %xmm1, %xmm0
cvtsi2sdl 0x29038(%rip), %xmm1 # 0x2d1f4
divsd %xmm1, %xmm0
leaq 0x21159(%rip), %rdi     # 0x25320
movb $0x1, %al
callq 0x2060
callq 0x4240
movl 0x29017(%rip), %eax     # 0x2d1f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jo-qzy[P]MyJson/test.cpp
// Function: test_parse()
static void test_parse() {
    test_parse_null();
    test_parse_true();
    test_parse_false();
    test_parse_number();
    test_parse_string();
    test_parse_array();
    test_parse_object();

    test_parse_expect_value();
    test_parse_invalid_value();
    test_parse_root_not_singular();
    test_parse_number_too_big();
    test_parse_missing_quotation_mark();
    test_parse_invalid_string_escape();
    test_parse_invalid_string_char();
    test_parse_invalid_unicode_hex();
    test_parse_invalid_unicode_surrogate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4710
callq 0x4ae0
callq 0x4eb0
callq 0x5280
callq 0xe3a0
callq 0x11710
callq 0x2690
callq 0x13030
callq 0x137b0
callq 0x13f30
callq 0x14e10
callq 0x15590
callq 0x15d10
callq 0x16bf0
callq 0x17370
callq 0x1a370
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: CheckTCid(char**, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, int)
int CheckTCid(char **lib_TC, std::vector<std::string> in_TC, int Length)  
{
	for (int i = 0; i < Length; i++)
	{
		if (strcmp(lib_TC[i], in_TC[i].c_str()) != 0)
		{
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x68f2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
callq 0x20d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x22c0
cmpl $0x0, %eax
je 0x68e5
movl $0x1, -0x4(%rbp)
jmp 0x68f9
jmp 0x68e7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x689e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ShellSort(double*, int*, int)
void ShellSort(double *num, int *index, int numLength)    
{
	int i, j, increment, temp_idx;
	double temp;

	for (increment = numLength / 2; increment > 0; increment /= 2)
	{
		for (i = increment; i<numLength; i++)
		{
			temp = num[i];
			temp_idx = index[i];
			for (j = i; j >= increment; j -= increment)
			{

				if (temp > num[j - increment])
				{
					num[j] = num[j - increment];
					index[j] = index[j - increment];
				}
				else
				{
					break;
				}
			}
			num[j] = temp;
			index[j] = temp_idx;
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x7800
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x77eb
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x77bd
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x77ac
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x77ae
jmp 0x77bd
jmp 0x77b0
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x774f
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x771d
jmp 0x77ed
movl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x770d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: GetRank(double*, double*, int)
void GetRank(double *rank, double *num,int numLength)
{
    int i,j,k;
    i = 0;
    while (i < numLength)
    {
        j = i;
        while ((j < numLength - 1) && (num[j]  == num[j + 1]))
        {
            j++;
        }
        if (i != j)
        {
            for (k = i; k <= j; k++)
            {
                rank[k] = (i + j + 2) / 2.0;
            }
        }
        else
        {
            rank[i] = i + 1;
        }
        i = j + 1;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x78f6
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jge 0x7874
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x787d
jmp 0x7888
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7838
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x78d1
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x78cf
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
addl $0x2, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7c05(%rip), %xmm1     # 0xf4b8
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7896
jmp 0x78e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7826
popq %rbp
retq
nopl (%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: StandardizeRow(double**, double*, double*, int, int)
void StandardizeRow(double **data_in, double *Mean, double *SD, int Length, int sample_size)  
{
	for (int i = 0; i < Length; i++)
	{
		if (SD[i] != 0)
		{
			for (int j = 0; j < sample_size; j++)
			{
				data_in[j][i] = (data_in[j][i] - Mean[i]) / SD[i];
			}
		}
		else
		{
			for (int j = 0; j < sample_size; j++)
			{
				data_in[j][i] = 0;
			}
		}

	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7c58
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7bb4
jp 0x7bb4
jmp 0x7c14
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7c12
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
divsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7bbb
jmp 0x7c48
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7c46
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7c1b
jmp 0x7c48
jmp 0x7c4a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7b8e
popq %rbp
retq
nopw (%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: StandardizeRow_r(double**, double*, double*, int, int)
void StandardizeRow_r(double **data_in, double *Mean, double *SD, int Length, int sample_size)  
{
	for (int i = 0; i < Length; i++)
	{
		for (int j = 0; j < sample_size; j++)
		{
			data_in[j][i] = data_in[j][i] * SD[i] + Mean[i];
		}

	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7cf9
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7cec
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7c8d
jmp 0x7cee
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7c7e
popq %rbp
retq
nopl (%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ClusterMean(double**, double**, int*, int, int, int)
void ClusterMean(double **data_matrix, double **data_mean, int *cluster_idx, int p_length, int c_length, int sample_size)
{
	double *data_sum = new double[sample_size];
	int data_count;

	for (int i = 0; i < c_length; i++)
	{
		for (int m = 0; m < sample_size; m++)
		{
			data_sum[m] = 0;
		}
		data_count = 0;
		for (int j = 0; j < p_length; j++)
		{
			if (cluster_idx[j] == i + 1)                      
			{
				for (int k = 0; k < sample_size; k++)
				{
					data_sum[k] += data_matrix[k][j];
				}
				data_count++;
			}
		}
		for (int m = 0; m < sample_size; m++)
		{
			data_mean[m][i] = data_sum[m] / (double)data_count;
		}

	}

	delete[] data_sum;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7e5c
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7d85
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7d62
movl $0x0, -0x34(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7e07
movq -0x18(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7dfa
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7df1
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7db7
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7dfc
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x7d93
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7e4c
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsi2sdl -0x34(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x7e0e
jmp 0x7e4e
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x7d4f
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x7e73
movq -0x50(%rbp), %rdi
callq 0x2260
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ReadPar(char*, int&, int&, int&, int&, int&, int&, int&, int&)
int ReadPar(char filename[255], int &loci_size, int &predictor_size, int &cluster_size, int &bin_size, int &var_size, int &DH_num1, int &DH_num2, int &DH_num3)
{
	FILE *pFile;
	int param[8];
	pFile = fopen(filename, "rb");
	if (pFile != NULL)
	{
		std::cout << "Reading model parameter..." << std::endl;
		fread(param, sizeof(int), 8, pFile);
		loci_size = param[0];
		predictor_size = param[1];
		cluster_size = param[2];
		bin_size = param[3];
		var_size = param[4];
		DH_num1 = param[5];
		DH_num2 = param[6];
		DH_num3 = param[7];
		fclose(pFile);

	}
	else
	{
		std::cout << "Error! File " << filename << " not found!" << std::endl;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x71a1(%rip), %rsi      # 0xf538
callq 0x2220
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8437
movq 0xdc26(%rip), %rdi      # 0x15fd8
leaq 0x7198(%rip), %rsi      # 0xf551
callq 0x21c0
movq %rax, %rdi
movq 0xdbf8(%rip), %rsi      # 0x15fc0
callq 0x2200
leaq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rcx
movl $0x4, %esi
movl $0x8, %edx
callq 0x22f0
movl -0x60(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x5c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x58(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x54(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x50(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x4c(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x48(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x44(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x21d0
jmp 0x847d
movq 0xdb9a(%rip), %rdi      # 0x15fd8
leaq 0x70da(%rip), %rsi      # 0xf51f
callq 0x21c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x70cc(%rip), %rsi      # 0xf52c
callq 0x21c0
movq %rax, %rdi
movq 0xdb51(%rip), %rsi      # 0x15fc0
callq 0x2200
movl $0x1, -0x4(%rbp)
jmp 0x8484
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: Regression(double**, double**, double**, int**, int, int, int)
void Regression(double **predictor, double **output, double **coef, int **predictor_idx, int var_length, int loci_length, int sample_size)
{
	for (int i = 0; i < loci_length; i++)
	{
		for (int j = 0; j < sample_size; j++)
		{
			output[j][i] = 0;
			for (int k = 0; k < var_length; k++)
			{
				output[j][i] += coef[k][i] * predictor[j][predictor_idx[k][i] - 1];               //index from 1 in library file.
			}

		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x8588
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x8578
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x8568
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x2c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x84f4
jmp 0x856a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x84c9
jmp 0x857a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x84b6
popq %rbp
retq
nopw (%rax,%rax)
// File: WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ModelAverage(double**, double**, double**, double**, double**, int**, int, int)
void ModelAverage(double **output, double **DH_pre1, double **DH_pre2, double **DH_pre3, double **dis_matrix, int **DH_cluster, int loci_length, int sample_size)
{
	double weight;
	for (int i = 0; i < loci_length; i++)
	{
		for (int j = 0; j < sample_size; j++)
		{
			weight = dis_matrix[0][i] + dis_matrix[1][i] + dis_matrix[2][i] + 1;
			output[j][i] = (output[j][i] + DH_pre1[j][DH_cluster[0][i] - 1] * dis_matrix[0][i] + DH_pre2[j][DH_cluster[1][i] - 1] * dis_matrix[1][i] + DH_pre3[j][DH_cluster[2][i] - 1] * dis_matrix[2][i]) / weight ;               //index from 1 in library file.
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x8723
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x8713
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd 0x69f6(%rip), %xmm1     # 0xf008
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x20(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x85cc
jmp 0x8715
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x85b9
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./mcounter-single.hh
// Function: UnsharedCounterParent::get()
uint64_t UnsharedCounterParent::get()
{
  uint64_t ret=d_formerChildren;
  std::lock_guard<std::mutex> l(d_mutex);
  for(const auto& c : d_children) {
    ret += c->d_value;
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x38, %rdi
callq 0x2bf0
movq -0x40(%rbp), %rsi
movq %rax, -0x10(%rbp)
addq $0x40, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2c80
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2cb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ce0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2d10
testb $0x1, %al
jne 0x24c7
jmp 0x24f1
leaq -0x28(%rbp), %rdi
callq 0x2d40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d70
jmp 0x24b4
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2da0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/point.cc
// Function: main
int main()
{
	cout << 10.0 << endl;         // prints 10
	cout << showpoint << 10.0     // prints 10.0000
	     << noshowpoint << endl;  // revert to default format 
	
	cout << 10.0 << endl;  // prints 10

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e02(%rip), %rdi      # 0x3fd8
movsd 0xe2a(%rip), %xmm0      # 0x2008
callq 0x1070
movq %rax, %rdi
movq 0x2ddb(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2ddf(%rip), %rdi      # 0x3fd8
leaq 0x60(%rip), %rsi        # 0x1260
callq 0x1030
movq %rax, %rdi
movsd 0xdf8(%rip), %xmm0      # 0x2008
callq 0x1070
movq %rax, %rdi
leaq 0x71(%rip), %rsi        # 0x1290
callq 0x1030
movq %rax, %rdi
movq 0x2d9a(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2d9e(%rip), %rdi      # 0x3fd8
movsd 0xdc6(%rip), %xmm0      # 0x2008
callq 0x1070
movq %rax, %rdi
movq 0x2d77(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: akw0088[P]openssl/rsync_upload.c
// Function: adler32
unsigned int adler32(unsigned char *data, unsigned int len)
{
	unsigned short a = 1, b = 0;
	unsigned int i;

	// Process each byte of the data in order
	for (i = 0; i < len; i++)
	{
		a = (a + data[i]) % MOD_ADLER;
		b = (b + a) % MOD_ADLER;
	}

	return (b << 16) | a;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movw $0x1, -0xe(%rsp)
movw $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x13c6
movzwl -0xe(%rsp), %eax
movq -0x8(%rsp), %rcx
movl -0x14(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xe(%rsp)
movzwl -0x10(%rsp), %eax
movzwl -0xe(%rsp), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x136f
movzwl -0x10(%rsp), %eax
shll $0x10, %eax
movzwl -0xe(%rsp), %ecx
orl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/rsync_upload.c
// Function: adler32_roll
unsigned int adler32_roll(unsigned int adler, unsigned char buf_in, unsigned char buf_out, unsigned int block_size)
{
	unsigned int a = adler & 0xFFFF;
	unsigned int b = adler >> 16;

	int a32 = (a + buf_in - buf_out);
	while (a32 < 0)
	{
		a32 += MOD_ADLER;
	}
	a = a32 % MOD_ADLER;

	int b32 = b + a - 1 - block_size * buf_out;
	while (b32 < 0)
	{
		b32 += MOD_ADLER;
	}
	b = b32 % MOD_ADLER;

	return (b << 16) | a;
}

// Assembly:
movb %dl, %al
movb %sil, %dl
movl %edi, -0x4(%rsp)
movb %dl, -0x5(%rsp)
movb %al, -0x6(%rsp)
movl %ecx, -0xc(%rsp)
movl -0x4(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
movzbl -0x5(%rsp), %ecx
addl %ecx, %eax
movzbl -0x6(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jge 0x1439
movl -0x18(%rsp), %eax
addl $0xfff1, %eax           # imm = 0xFFF1
movl %eax, -0x18(%rsp)
jmp 0x1423
movl -0x18(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movl %edx, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl -0x10(%rsp), %eax
subl $0x1, %eax
movl -0xc(%rsp), %ecx
movzbl -0x6(%rsp), %edx
imull %edx, %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jge 0x147c
movl -0x1c(%rsp), %eax
addl $0xfff1, %eax           # imm = 0xFFF1
movl %eax, -0x1c(%rsp)
jmp 0x1466
movl -0x1c(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
shll $0x10, %eax
orl -0x10(%rsp), %eax
retq
nopl (%rax,%rax)
// File: akw0088[P]openssl/rsync_upload.c
// Function: Recv
int Recv(SOCKET sock, char *buffer, unsigned int size, int flag)
{
	unsigned int num_read = 0;

	while (num_read < size && num_read >= 0)
	{
		int ret = 0;

		ret = recv(sock, &buffer[num_read], size - num_read, flag);
		if (ret > 0)
		{
			num_read += ret;
			if (size > RECV_PROGRESS)
			{
				printf("Recv %d of %d\r", num_read, size);
			}
		}
		else
		{
			return ret;
		}
	}
	if (size > RECV_PROGRESS)
	{
		printf("\r\n");
	}
	return num_read;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x14(%rsp), %ecx
movb %al, 0x7(%rsp)
jae 0x1829
cmpl $0x0, 0xc(%rsp)
setae %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1833
jmp 0x18a8
movl $0x0, 0x8(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %eax
addq %rax, %rsi
movl 0x14(%rsp), %eax
subl 0xc(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
movl 0x10(%rsp), %ecx
callq 0x1040
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x1899
movl 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jbe 0x1897
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
leaq 0x37c6(%rip), %rdi      # 0x5056
movb $0x0, %al
callq 0x10e0
jmp 0x18a3
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x18c8
jmp 0x180d
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jbe 0x18c0
leaq 0x3aa9(%rip), %rdi      # 0x5362
movb $0x0, %al
callq 0x10e0
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/rsync_upload.c
// Function: Send
int Send(SOCKET sock, char *buffer, int size, int flag)
{
	int num_sent = 0;

	while (num_sent < size && num_sent >= 0)
	{
		int ret = 0;

		ret = send(sock, &buffer[num_sent], size - num_sent, flag);
		if (ret > 0)
		{
			num_sent += ret;

			if (size > RECV_PROGRESS)
			{
				printf("Sent %d of %d\r", num_sent, size);
			}
		}
		else
		{
			return ret;
		}
	}
	if (size > RECV_PROGRESS)
	{
		printf("\r\n");
	}
	return num_sent;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x14(%rsp), %ecx
movb %al, 0x7(%rsp)
jge 0x1919
cmpl $0x0, 0xc(%rsp)
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1923
jmp 0x1998
movl $0x0, 0x8(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movslq 0xc(%rsp), %rax
addq %rax, %rsi
movl 0x14(%rsp), %eax
subl 0xc(%rsp), %eax
movslq %eax, %rdx
movl 0x10(%rsp), %ecx
callq 0x10d0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x1989
movl 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jle 0x1987
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
leaq 0x36e5(%rip), %rdi      # 0x5065
movb $0x0, %al
callq 0x10e0
jmp 0x1993
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x19b8
jmp 0x18fd
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
jle 0x19b0
leaq 0x39b9(%rip), %rdi      # 0x5362
movb $0x0, %al
callq 0x10e0
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/rsync_upload.c
// Function: write_file
int write_file(char *filename, const char *bytes, int size)
{
    FILE *fp = fopen(filename, "wb");
    int ret;
    
    if (fp == NULL)
    {
        perror("Unable to open file for writing");
        return -1;
    }
    
    ret = fwrite(bytes, sizeof(char), size, fp);
    
    if (ret != size)
    {
		perror("fwrite didnt write all data");
		fclose(fp);
        return -1;
    }
    fclose(fp);
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x3579(%rip), %rsi      # 0x5077
callq 0x11c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1b26
leaq 0x3563(%rip), %rdi      # 0x507a
callq 0x11d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1b7f
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x1220
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x1b6d
leaq 0x3546(%rip), %rdi      # 0x509a
callq 0x11d0
movq 0x10(%rsp), %rdi
callq 0x1090
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1b7f
movq 0x10(%rsp), %rdi
callq 0x1090
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: akw0088[P]openssl/rsync_upload.c
// Function: assemble_download
int assemble_download(char *response, unsigned int rfile_size, char *data, unsigned int file_size, block_t *block_offset, int num_block, unsigned int block_size, char *diff, unsigned int diff_size)
{
	unsigned int diff_pos = 0;

	memset(response, 0, rfile_size);
	for (unsigned int i = 0; i < rfile_size; i++)
	{
		int skip = 0;

		// check if this byte is in a block
		for (int j = 0; j < num_block; j++)
		{
			if (i >= block_offset[j].offset && i < block_offset[j].offset + block_size)
			{
				// we are in this block, memcpy and skip to the end of this block
				memcpy(&response[i], &data[j * block_size], block_offset[j].length);
				i = block_offset[j].offset + block_size - 1;
				skip = 1;
				break;
			}
		}

		if (skip)
		{
			// restart again as we move passed a block
			continue;
		}

		// This byte comes from the downloaded pile
		response[i] = diff[diff_pos++];
	}

	return 0;
}

// Assembly:
subq $0x48, %rsp
movl 0x60(%rsp), %eax
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x1110
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x1cdb
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1c9f
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
movslq 0xc(%rsp), %rdx
cmpl (%rcx,%rdx,8), %eax
jb 0x1c8d
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movl (%rcx,%rdx,8), %ecx
addl 0x50(%rsp), %ecx
cmpl %ecx, %eax
jae 0x1c8d
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %eax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movl 0xc(%rsp), %eax
imull 0x50(%rsp), %eax
movl %eax, %eax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, %edx
callq 0x1160
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,8), %eax
addl 0x50(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0x1c9f
jmp 0x1c8f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1bfd
cmpl $0x0, 0x10(%rsp)
je 0x1ca8
jmp 0x1ccb
movq 0x58(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x18(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x40(%rsp), %rax
movl 0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1bdf
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)