LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/graph.cpp
// Function: GraphAlgo::graph::print_neighborhood() const
void graph::
print_neighborhood() const
{
	neighborhood::const_iterator it = m_neighborhood.begin();
	for ( ; it != m_neighborhood.end(); ++it ) 
	{
		std::cout << std::setw(2) << it->first << "  --> " ;
		
		vertices::const_iterator v_it = it->second.begin();
		for ( ; v_it != it->second.end(); ++v_it ) 
		{
			std::cout << std::setw(2) << *v_it;
			if ( v_it != (it->second.end() - 1) ) 
			{
				std::cout << ", " ;
			}
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
addq $0x38, %rbx
cmpq %rbx, %r14
je 0x8e09
movq 0x928c(%rip), %r15      # 0x11fd8
leaq 0x33c7(%rip), %r12      # 0xc11a
leaq 0x33c7(%rip), %r13      # 0xc121
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r15,%rax)
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x21f0
movl $0x6, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
movq 0x28(%r14), %rbp
cmpq 0x30(%r14), %rbp
je 0x8dce
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r15,%rax)
movl (%rbp), %esi
movq %r15, %rdi
callq 0x21f0
movq 0x30(%r14), %rax
addq $-0x4, %rax
cmpq %rax, %rbp
je 0x8dc8
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2180
addq $0x4, %rbp
jmp 0x8d8a
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2190
movq %rax, %r14
cmpq %rbx, %rax
jne 0x8d5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AraKhachatryan[P]GraphAlgo/main.cpp
// Function: draw_graph(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>>>> const&)
void draw_graph( const std::vector<std::string> &graph_data )
{
	// Printing a graph via graph_data
	std::cout << std::endl;
	std::cout << terminal::TEXT_BOLD << terminal::TEXTCOLOR_BLUE;
	
	for ( auto &line : graph_data )
	{
		std::cout << "   " << line << std::endl;
	}
	
	std::cout << terminal::RESET_ALL;
	std::cout << std::endl;
	std::cout << "................................................................................" << std::endl;	
	
	std::this_thread::sleep_for(std::chrono::milliseconds(4000));   // sleep
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x6b42(%rip), %rbx      # 0x11fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x2439(%rip), %r15      # 0xd8fd
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
movq %rbx, %rdi
movl $0x1, %esi
callq 0x21f0
movq %rax, %r12
leaq 0x2415(%rip), %r13      # 0xd900
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movl $0x2, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2180
movq %r12, %rdi
movl $0x22, %esi
callq 0x21f0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0xb595
movq 0x6a9d(%rip), %r14      # 0x11fd8
leaq 0x151d(%rip), %r15      # 0xca5f
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
addq $0x20, %r13
cmpq %rbp, %r13
jne 0xb542
leaq 0x2361(%rip), %rsi      # 0xd8fd
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21f0
leaq 0x2346(%rip), %rsi      # 0xd900
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x22b7(%rip), %rsi      # 0xd8ac
movl $0x50, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rbx
movq $0x4, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2080
cmpl $-0x1, %eax
jne 0xb657
callq 0x2040
cmpl $0x4, (%rax)
je 0xb63d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::connectGateway()
void LogicServer::connectGateway()
{
    gatefd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in gatewayAddr;

    gatewayAddr.sin_family = AF_INET;
    gatewayAddr.sin_port = 8898;
    inet_aton("127.0.0.1",&(gatewayAddr.sin_addr));
    
    bind(gatefd, (struct sockaddr*)&gatewayAddr, sizeof(gatewayAddr));
    
    gatewayAddr.sin_family = AF_INET;
    gatewayAddr.sin_port = htons(gateway.second);
    inet_aton(gateway.first.c_str(), &(gatewayAddr.sin_addr));
    ::connect(gatefd, (struct sockaddr*)&gatewayAddr, sizeof(gatewayAddr));

    Client *gate = new Client(gatefd);
    ev.data.ptr = gate;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, gatefd, &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, 0x168(%rbx)
leaq -0x2c(%rbp), %r14
movl $0x22c20002, -0x4(%r14) # imm = 0x22C20002
leaq 0x45bb(%rip), %rdi      # 0x7058
movq %r14, %rsi
callq 0x2190
movl 0x168(%rbx), %edi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
movl $0x10, %edx
callq 0x2050
movw $0x2, (%r15)
movzwl 0x190(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r15)
movq 0x170(%rbx), %rdi
movq %r14, %rsi
callq 0x2190
movl 0x168(%rbx), %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x21b0
movl $0x2024, %edi           # imm = 0x2024
callq 0x2200
movl 0x168(%rbx), %edx
movq %r12, 0x1004(%rax)
movl %r12d, 0x100c(%rax)
movq %r12, 0x2014(%rax)
movl %r12d, 0x201c(%rax)
movl %edx, 0x2020(%rax)
leaq 0x1c(%rbx), %rcx
movq %rax, 0x20(%rbx)
movl $0x1, 0x1c(%rbx)
movl 0x10(%rbx), %edi
movl $0x1, %esi
callq 0x22a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::Run()
void LogicServer::Run()
{
    int n = epoll_wait(epfd, events, 20, 500);
    for (int i = 0; i < n; i++) {
        if (events[i].data.fd == listenfd) {
            acceptConnect();
        }
        else {
            Client* cli = (Client*)events[i].data.ptr;
            int ret = cli->Recv();
            PacketInfo pi; string content;
            bool has = cli->hasMsg(&pi, content);
            if (has) {
                Dispatch(cli, &pi, content);
            }
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %edi
leaq 0x28(%rbx), %rsi
movl $0x14, %edx
movl $0x1f4, %ecx            # imm = 0x1F4
callq 0x2110
testl %eax, %eax
jle 0x2c39
leaq -0x38(%rbp), %r15
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
xorl %r14d, %r14d
movl 0x2c(%rbx,%r14), %eax
cmpl 0x14(%rbx), %eax
jne 0x2bab
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
jmp 0x2c2c
movq 0x2c(%rbx,%r14), %r13
movq %r13, %rdi
callq 0x6224
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %r13, %rdi
leaq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x62ba
testb %al, %al
je 0x2c1e
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x3850
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x80(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq *0x10(%rax)
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2c1e
callq 0x21d0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c2c
callq 0x21d0
addq $0xc, %r14
cmpq %r14, %r12
jne 0x2b93
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2c62
callq 0x21d0
jmp 0x2c62
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c70
callq 0x21d0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::Dispatch(fieryzig::Client*, fieryzig::PacketInfo*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void LogicServer::Dispatch(Client* cli, PacketInfo *ppi, string content)
{
    switch(ppi->srcType) {
        case ServerType::CLIENT:
        {
            // impossible
            break;
        }
        case ServerType::GATEWAY:
        {
            if (content == "Login") {
                fd_map[ppi->uid] = ppi->clifd;
                Player* player = new Player(ppi->uid);
                pl_map[ppi->uid] = player;
                cout << "User " << ppi->uid << "Login" << endl;
            }
            else if (content == "Logout") {
                delete pl_map[ppi->uid];
                pl_map.erase(ppi->uid);
                fd_map.erase(ppi->uid);
                cout << "User " << ppi->uid << "Logout" << endl;
            }
            // Other Msg
            break;
        }
        case ServerType::LOGIC:
        {
            break;
        }
        // DB Cache
    }

}

// Assembly:
cmpl $0x1, (%rdx)
jne 0x2e0c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x43c4(%rip), %rsi      # 0x7062
movq %rcx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x2d5c
leaq 0x43b9(%rip), %rsi      # 0x706e
movq %r15, %rdi
callq 0x20b0
testl %eax, %eax
jne 0x2e02
leaq 0x198(%r14), %r15
movl 0x8(%rbx), %eax
addq $0x8, %rbx
leaq -0x20(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x3614
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2cee
callq 0x21d0
movl (%rbx), %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x3d9c
movq %r15, %rdi
movq %rax, %rsi
callq 0x3e18
addq $0x1c8, %r14            # imm = 0x1C8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f12
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f8e
movq 0xa2ab(%rip), %r14      # 0xcfd8
leaq 0x4334(%rip), %rsi      # 0x7068
movl $0x5, %edx
movq %r14, %rdi
callq 0x2240
movl (%rbx), %esi
movq %r14, %rdi
callq 0x2340
movq %rax, %rbx
leaq 0x4319(%rip), %rsi      # 0x706e
movl $0x6, %edx
jmp 0x2dd3
movl 0x10(%rbx), %r15d
leaq 0x1c8(%r14), %rdi
leaq 0x8(%rbx), %rsi
callq 0x35ac
movl %r15d, (%rax)
movl $0x4, %edi
callq 0x2200
movq %rax, %r15
movl 0x8(%rbx), %eax
movl %eax, (%r15)
addq $0x198, %r14            # imm = 0x198
leaq -0x24(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x3614
movq %r15, (%rax)
movq 0xa233(%rip), %r14      # 0xcfd8
leaq 0x42bc(%rip), %rsi      # 0x7068
movl $0x5, %edx
movq %r14, %rdi
callq 0x2240
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x2340
movq %rax, %rbx
leaq 0x4294(%rip), %rsi      # 0x7062
movl $0x5, %edx
movq %rax, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fieryzig[P]GameServer/LogicServer/LogicServer.cpp
// Function: fieryzig::LogicServer::acceptConnect()
void LogicServer::acceptConnect()
{
    socklen_t clilen;
    connfd = accept(listenfd, (sockaddr*)&clientaddr, &clilen);
    Client *client = new Client(connfd);

    // DB Cache Server ? may connect in?
    //
    ev.data.ptr = client;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %edi
leaq 0x118(%rbx), %rsi
leaq -0x14(%rbp), %rdx
callq 0x20d0
movl %eax, %r14d
movl %eax, 0x18(%rbx)
movl $0x2024, %edi           # imm = 0x2024
callq 0x2200
xorl %ecx, %ecx
movq %rcx, 0x1004(%rax)
movl %ecx, 0x100c(%rax)
movq %rcx, 0x2014(%rax)
movl %ecx, 0x201c(%rax)
movl %r14d, 0x2020(%rax)
leaq 0x1c(%rbx), %rcx
movq %rax, 0x20(%rbx)
movl $0x1, 0x1c(%rbx)
movl 0x10(%rbx), %edi
movl $0x1, %esi
movl %r14d, %edx
callq 0x22a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fieryzig[P]GameServer/LogicServer/main.cpp
// Function: main
int main()
{
    LogicServer *logicServer = new LogicServer();
    
    logicServer->SetConfig("logicConfig.json");
    logicServer->InitServer();
    
    logicServer->connectGateway();
    
    while(1)
    {
        logicServer->Run();
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x1f8, %edi            # imm = 0x1F8
callq 0x2200
movq %rax, %rbx
xorl %r14d, %r14d
movl $0x1f8, %edx            # imm = 0x1F8
movq %rax, %rdi
xorl %esi, %esi
callq 0x2130
movq %r14, 0x8(%rbx)
leaq 0x6cd7(%rip), %rax      # 0xcd30
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x140(%rbx), %rax
movl %r14d, 0x140(%rbx)
movq %r14, 0x148(%rbx)
movq %rax, 0x150(%rbx)
movq %rax, 0x158(%rbx)
movq %r14, 0x160(%rbx)
leaq 0x180(%rbx), %rax
movq %rax, 0x170(%rbx)
movq %r14, 0x178(%rbx)
movb $0x0, 0x180(%rbx)
movl %r14d, 0x190(%rbx)
leaq 0x1a0(%rbx), %rax
movl %r14d, 0x1a0(%rbx)
movq %r14, 0x1a8(%rbx)
movq %rax, 0x1b0(%rbx)
movq %rax, 0x1b8(%rbx)
movq %r14, 0x1c0(%rbx)
leaq 0x1d0(%rbx), %rax
movl %r14d, 0x1d0(%rbx)
movq %r14, 0x1d8(%rbx)
movq %rax, 0x1e0(%rbx)
movq %rax, 0x1e8(%rbx)
movq %r14, 0x1f0(%rbx)
leaq 0x39c0(%rip), %rsi      # 0x9ac8
movq %rbx, %rdi
callq 0x2e0e
movq %rbx, %rdi
callq 0x612c
movq %rbx, %rdi
callq 0x2a5e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/supragya[P]DirectorySync/DirectorySync.cpp
// Function: set_filewatcher_connection(int, char*)
void set_filewatcher_connection(int portno, char* ipaddr){
    // Network setup with other Droid
    struct sockaddr_in address;
    int sock = 0;
    struct sockaddr_in serv_addr;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        std::cout<<"[FC] Socket creation error"<<std::endl;
        exit(1);
    }

    memset(&serv_addr, '0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(portno);

    // Convert IPv4 and IPv6 addresses from text to binary form
    if(inet_pton(AF_INET, ipaddr, &serv_addr.sin_addr)<=0)
    {
        std::cout<<"[FC] Invalid address/ Address not supported "<<std::endl;
        exit(1);
    }
    std::cout<<"[FC] Other bot ready to accept communication?";
    char ch;
    std::cin>>ch;
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        std::cout<<"[FC] Connection Failed"<<std::endl;
        exit(1);
    }
    else
        std::cout<<"[FC] Successfully setup connection with other droid\n";

    FCsock = sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %r15d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
testl %eax, %eax
js 0x2b28
movl %eax, %ebx
movaps 0x2576(%rip), %xmm0     # 0x5010
leaq -0x2c(%rbp), %rdx
movaps %xmm0, -0x4(%rdx)
movw $0x2, -0x4(%rdx)
rolw $0x8, %r15w
movw %r15w, -0x2(%rdx)
movl $0x2, %edi
movq %r14, %rsi
callq 0x2340
movq 0x550a(%rip), %rdi      # 0x7fd0
testl %eax, %eax
jle 0x2b38
leaq 0x282c(%rip), %rsi      # 0x52fd
movl $0x2d, %edx
callq 0x21e0
movq 0x54fe(%rip), %rdi      # 0x7fe0
leaq -0x19(%rbp), %rsi
callq 0x2220
leaq -0x30(%rbp), %rsi
movl %ebx, %edi
movl $0x10, %edx
callq 0x2150
movq 0x54ce(%rip), %rdi      # 0x7fd0
testl %eax, %eax
js 0x2b41
leaq 0x2835(%rip), %rsi      # 0x5342
movl $0x34, %edx
callq 0x21e0
movl %ebx, 0x1e76b(%rip)     # 0x21288
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x54a1(%rip), %rdi      # 0x7fd0
leaq 0x277f(%rip), %rsi      # 0x52b5
jmp 0x2b48
leaq 0x2791(%rip), %rsi      # 0x52d0
jmp 0x2b48
leaq 0x27e3(%rip), %rsi      # 0x532b
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/supragya[P]DirectorySync/DirectorySync.cpp
// Function: FormMessage(char*, FileChangeType_t, FileType_t, unsigned long)
message* FormMessage(char *filename, FileChangeType_t fctype, FileType_t ftype, unsigned long filesize){
    message* newmsg = (message *)malloc(sizeof(message));
    strcpy(newmsg->FileName, filename);
    newmsg->FType = ftype;
    newmsg->FCType = fctype;
    newmsg->FileSize = filesize;
    newmsg->valid = 1;
    return newmsg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x400, %edi            # imm = 0x400
callq 0x2230
movq %rax, %r13
leaq 0x4(%rax), %rdi
movq %r12, %rsi
callq 0x2180
movl %r14d, 0x3f0(%r13)
movl %r15d, 0x3ec(%r13)
movq %rbx, 0x3f8(%r13)
movl $0x1, (%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/supragya[P]DirectorySync/DirectorySync.cpp
// Function: TransactionHistory_t::is_recorded(message)
bool is_recorded(message m){
        mtx.lock();
        bool FoundRecord = false;
        // Pass 1: Hard
        for(int i=0; i<MAXTRANSACTIONS; i++){
            if(!ValidTransactionHistory[i])
                continue;
            if( strcmp(m.FileName, TransactionHistory[i].FileName) == 0 &&
                m.FType == TransactionHistory[i].FType &&
                m.FileSize == TransactionHistory[i].FileSize &&
                m.FCType == TransactionHistory[i].FCType){
                    FoundRecord = true;
                    ValidTransactionHistory[i] = false;
                    break;
            }
        }
        // Pass 2: Soft
        if(!FoundRecord){
            for(int i=0; i<MAXTRANSACTIONS; i++){
                if(!ValidTransactionHistory[i])
                    continue;
                if( strcmp(m.FileName, TransactionHistory[i].FileName) == 0 &&
                    m.FType == TransactionHistory[i].FType ){
                    FoundRecord = true;
                    break;
                }
            }
        }
        mtx.unlock();
        return FoundRecord;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x19068, %rdi          # imm = 0x19068
movq %rdi, -0x38(%rbp)
callq 0x2270
testl %eax, %eax
jne 0x422c
leaq 0x10(%rbp), %rax
leaq 0x4(%rax), %r15
movl 0x3ec(%rax), %ecx
movl %ecx, -0x30(%rbp)
movl 0x3f0(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x3f8(%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x6c(%rbx), %r12
xorl %r13d, %r13d
movq %rbx, %r14
cmpb $0x1, (%r14)
jne 0x419b
leaq (%r12,%r13), %rsi
movq %r15, %rdi
callq 0x2250
testl %eax, %eax
jne 0x419b
movl -0x2c(%rbp), %eax
cmpl 0x458(%rbx,%r13), %eax
jne 0x419b
movq -0x40(%rbp), %rax
cmpq 0x460(%rbx,%r13), %rax
jne 0x419b
movl -0x30(%rbp), %eax
cmpl 0x454(%rbx,%r13), %eax
je 0x4223
incq %r14
addq $0x400, %r13            # imm = 0x400
cmpq $0x19000, %r13          # imm = 0x19000
jne 0x4159
xorl %r14d, %r14d
testb %r14b, %r14b
jne 0x4203
movl %r14d, -0x2c(%rbp)
leaq 0x10(%rbp), %rax
movl 0x3f0(%rax), %r14d
leaq 0x458(%rbx), %r13
xorl %r12d, %r12d
cmpb $0x1, (%rbx,%r12)
jne 0x41ef
leaq -0x3ec(%r13), %rsi
movq %r15, %rdi
callq 0x2250
testl %eax, %eax
jne 0x41ef
cmpl (%r13), %r14d
je 0x421e
incq %r12
addq $0x400, %r13            # imm = 0x400
cmpq $0x64, %r12
jne 0x41cf
movl -0x2c(%rbp), %r14d
movq -0x38(%rbp), %rdi
callq 0x2140
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r14b
jmp 0x4203
movb $0x0, (%r14)
movb $0x1, %r14b
jmp 0x41b1
movl %eax, %edi
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriFourny[P]uaf_replacer/main.cc
// Function: map_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
char* map_file(const std::string& filepath, size_t& filesize) {
  FILE* hfile = fopen(filepath.c_str(), "rb");
  if (!hfile) {
    fprintf(stderr, "ERR: Failed to open '%s'\n", filepath.c_str());
    return nullptr;
  }

  fseek(hfile, 0, SEEK_END);
  filesize = ftell(hfile);
  fseek(hfile, 0, SEEK_SET);

  char* memfile = reinterpret_cast<char*>(malloc(filesize+1));
  size_t nb_read = fread(memfile, filesize, 1, hfile);
  fclose(hfile);
  if (nb_read != 1) {
    fprintf(stderr, "ERR: Failed to read '%s'\n", filepath.c_str());
    return nullptr;
  }

  return reinterpret_cast<char*>(memfile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x4a04(%rip), %rsi      # 0x7058
callq 0x21a0
testq %rax, %rax
je 0x26ca
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2160
movq %r14, %rdi
callq 0x2030
movq %rax, (%r15)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq (%r15), %r12
leaq 0x1(%r12), %rdi
callq 0x21d0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x2200
movq %rax, %r12
movq %r14, %rdi
callq 0x2120
cmpq $0x1, %r12
jne 0x26d3
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x498a(%rip), %rsi      # 0x705b
jmp 0x26da
leaq 0x499b(%rip), %rsi      # 0x7075
movq %rbx, %rdi
callq 0x2290
xorl %r15d, %r15d
jmp 0x26bb
// File: /workspace/github_cpp_makefile_star2_O1/DimitriFourny[P]uaf_replacer/main.cc
// Function: dump_parent(rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator> const&, char const*, unsigned long, unsigned int)
void dump_parent(const rapidjson::Document& document, const char* parent_id, 
                 uint64_t base_offset, unsigned int deep_size) {
  printf("    +0x%-3lx ", base_offset);
  for (size_t j = 0; j < deep_size; j++) {
    printf("    ");
  }

  if (!document.HasMember(parent_id) || 
      !document[parent_id].HasMember("name")) {
    printf(": unknown_parent\n");
    return;
  }

  const char* type = "";
  if (document[parent_id].HasMember("type")) {
    type = document[parent_id]["type"].GetString();
  }

  printf(": %s %s\n", type, document[parent_id]["name"].GetString());

  if (document[parent_id].HasMember("members")) {
    dump_members(document, document[parent_id], document[parent_id]["members"],
      base_offset, deep_size+1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x3be9(%rip), %rdi      # 0x70d2
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2050
testl %ebx, %ebx
je 0x350f
movl %ebx, %ebp
leaq 0x3be0(%rip), %r13      # 0x70e0
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
decq %rbp
jne 0x3500
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x44fa
movq (%r13), %r13
movq %r15, %rdi
callq 0x44ba
cmpq %rax, %r13
je 0x35c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
movq %rax, %r13
leaq 0x3b47(%rip), %rdx      # 0x7091
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x44fa
movq (%rbp), %rbp
movq %r13, %rdi
callq 0x44ba
cmpq %rax, %rbp
je 0x35c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
movq %rax, %r13
leaq 0x3b18(%rip), %rdx      # 0x7096
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x44fa
movq (%rbp), %rbp
movq %r13, %rdi
callq 0x44ba
cmpq %rax, %rbp
je 0x35d5
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
leaq 0x3ae7(%rip), %rsi      # 0x7096
movq %rax, %rdi
callq 0x473c
movq %rax, %rdi
callq 0x4160
movq %rax, %r13
jmp 0x35dc
leaq 0x5e72(%rip), %rdi      # 0x943d
callq 0x2220
jmp 0x3684
leaq 0x3ab2(%rip), %r13      # 0x708e
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
leaq 0x3aa3(%rip), %rsi      # 0x7091
movq %rax, %rdi
callq 0x473c
movq %rax, %rdi
callq 0x4160
leaq 0x3ae8(%rip), %rdi      # 0x70ed
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
movq %rax, %r13
leaq 0x3abe(%rip), %rdx      # 0x70e5
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x44fa
movq (%rbp), %rbp
movq %r13, %rdi
callq 0x44ba
cmpq %rax, %rbp
je 0x3684
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x473c
leaq 0x3a7f(%rip), %rsi      # 0x70e5
movq %rax, %rdi
callq 0x473c
incl %ebx
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x3083
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/CountDiv.cpp
// Function: solution(int, int, int)
int solution(int A, int B, int K) {
	int start = A;// The minimal value equal or greater than A that is divisible by K
	int r = A % K;
	if (r > 0) {
		start += K - r;
	}

	int len = B - start;
	if (len < 0) {
		return 0;
	}
	return len / K + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %ecx
movl %edi, %eax
cltd
idivl %ecx
movl %edx, %r8d
subl %ecx, %r8d
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r8d
subl %edi, %esi
addl %r8d, %esi
js 0x11d3
movl %esi, %eax
cltd
idivl %ecx
incl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/global.cpp
// Function: Context::init(int)
void Context::init(int32_t aNumNode)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	clear(); //avoid double allocation

	int32_t n2 = aNumNode * 2;

	markCell = new int32_t[n2];
	markNode = new int32_t[n2];

	memset(markCell, 0, sizeof(int32_t) * n2);
	memset(markNode, 0, sizeof(int32_t) * n2);

	global_mark = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x3454
leal (%r14,%r14), %eax
movslq %eax, %r15
shlq $0x2, %r15
testl %r14d, %r14d
movq $-0x1, %r14
cmovnsq %r15, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x8(%rbx)
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
movl $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/global.cpp
// Function: Context::clear()
void Context::clear()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	global_mark = 0;

	if( markCell != NULL ) {
		delete[] markCell;
		markCell = NULL;
	}
	if( markNode != NULL ) {
		delete[] markNode;
		markNode = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x10(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3473
callq 0x21f0
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3489
callq 0x21f0
movq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/graph.cpp
// Function: Graph::clear()
void Graph::clear()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if(d != NULL) {
		delete[] d;
		d = NULL;
	}
	if(l != NULL) {
		delete[] l;
		l = NULL;
	}
	if(one != NULL) {
		delete[] one;
		one = NULL;
	}
	if(e != NULL) {
		for(int32_t i = 0; i < numNode; ++i) {
			if(e[i] != NULL) {
				delete[] e[i];
			}
		}
		delete[] e;
		e = NULL;
	}
	if(adjPos != NULL) {
		delete[] adjPos;
		adjPos = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x45e5
callq 0x21f0
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x45fb
callq 0x21f0
movq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x4611
callq 0x21f0
movq $0x0, 0x30(%rbx)
cmpq $0x0, 0x38(%rbx)
je 0x4655
cmpl $0x0, 0xc(%rbx)
jle 0x463f
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4633
callq 0x21f0
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x4621
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x464d
callq 0x21f0
movq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x466b
callq 0x21f0
movq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/graph.cpp
// Function: DAG::clear()
void DAG::clear()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif 

	if(childSize != NULL) {
		delete[] childSize;
		childSize = NULL;
	}
	if(parentSize != NULL) {
		delete[] parentSize;
		parentSize = NULL;
	}
	if(dagArr != NULL) {
		delete[] dagArr;
		dagArr = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4778
callq 0x21f0
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x478e
callq 0x21f0
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x47a4
callq 0x21f0
movq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/memory.cpp
// Function: Memory::~Memory()
Memory::~Memory()
{
	for(int32_t i = 0; i < (int32_t)createdArray.size(); ++i) {
		delete[] createdArray[i];
	}
	createdArray.clear();
	llPool.clear();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x4ae9
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4acd
callq 0x21f0
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x4abf
cmpq %rax, %rcx
je 0x4af2
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdi
cmpq %rdi, 0x20(%rbx)
je 0x4b00
movq %rdi, 0x20(%rbx)
testq %rdi, %rdi
je 0x4b11
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4b2c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/memory.cpp
// Function: Memory::returnLLArray(int*, int)
void Memory::returnLLArray(int32_t* aArray, int32_t aSize)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	llPool.push_back(make_pair(aArray, aSize));
	
	//cout << aSize << " is returned" << endl;
}

// Assembly:
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq 0x20(%rdi), %rsi
cmpq 0x28(%rdi), %rsi
je 0x4d16
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x20(%rdi)
jmp 0x4d24
addq $0x18, %rdi
leaq 0x8(%rsp), %rdx
callq 0x4e66
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/algorithm.cpp
// Function: Algorithm::run(Graph*, Graph*)
bool Algorithm::run(Graph* aG1, Graph* aG2)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	// Context cont;
	cont.init(aG1->numNode);

	Refinement cr(cont);
	bool result = cr.run(aG1, aG2);
	if (result == false) {
		return false;
	}

	Coloring* coloring = cr.getStableColoring();

	Backtrack bt(cont);
	result = bt.run(coloring, aG1, aG2, cr.getNumTreeNode());
    setSearchTime(bt.getSearchTime());
    setNumRecur(bt.getNumRecur());

	if(result) //if isomorphic
		computeIso(aG1, aG2, bt.mapping, coloring);

	cont.clear();
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0xc(%rsi), %esi
callq 0x33de
movq (%rbx), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x934c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x94d0
testb %al, %al
je 0x50f8
leaq 0x8(%rsp), %rdi
callq 0xac4e
movq %rax, %r12
movq (%rbx), %rsi
leaq 0x90(%rsp), %rdi
callq 0x5d68
leaq 0x8(%rsp), %rdi
callq 0xac52
leaq 0x90(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %eax, %r8d
callq 0x6046
movl %eax, %ebp
leaq 0x90(%rsp), %rdi
callq 0x6032
movsd %xmm0, 0x8(%rbx)
leaq 0x90(%rsp), %rdi
callq 0x6038
movl %eax, 0x10(%rbx)
testb %bpl, %bpl
je 0x50e1
movq 0xe0(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %r8
callq 0x5142
movq (%rbx), %rdi
callq 0x3454
leaq 0x90(%rsp), %rdi
callq 0x5dd4
jmp 0x50fa
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x939e
movl %ebp, %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x511a
jmp 0x511a
movq %rax, %rbx
jmp 0x512f
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x5dd4
leaq 0x8(%rsp), %rdi
callq 0x939e
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/algorithm.cpp
// Function: Algorithm::printIso(char const*, char const*, char const*)
void Algorithm::printIso(const char* ifname1, const char* ifname2, const char* ofname)
{
	ofstream outfile(ofname);

	outfile << "V(" << ifname1 << ") : V(" << ifname2 << ")" << endl;
	for(int32_t vid = 0; vid < numNode; ++vid)
		outfile << vid << ":" << mapping[vid] << endl;

	outfile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
movl $0x10, %edx
callq 0x21b0
leaq 0x6e79(%rip), %rsi      # 0xc36c
movl $0x2, %edx
movq %r12, %rdi
callq 0x21c0
testq %r15, %r15
je 0x551d
movq %r15, %rdi
callq 0x20c0
movq %rsp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x5534
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x6e2d(%rip), %rsi      # 0xc368
movq %rsp, %rdi
movl $0x6, %edx
callq 0x21c0
testq %r14, %r14
je 0x5565
movq %r14, %rdi
callq 0x20c0
movq %rsp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x557c
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x6ab2(%rip), %rsi      # 0xc035
movq %rsp, %r14
movl $0x1, %edx
movq %r14, %rdi
callq 0x21c0
movq (%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rsp, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
cmpl $0x0, 0x20(%rbx)
jle 0x5632
xorl %r14d, %r14d
movq %rsp, %r15
leaq 0x6a76(%rip), %r12      # 0xc044
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq 0x18(%rbx), %rax
movl (%rax,%r14,4), %esi
movq %r13, %rdi
callq 0x22d0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0x55ce
movq %rsp, %rdi
callq 0x2220
movq 0xa977(%rip), %rax      # 0xffb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2140
leaq 0xf8(%rsp), %rdi
callq 0x2090
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x567e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::Backtrack(Context&)
Backtrack::Backtrack(Context& aContext)
{
    searchTime = 0.0;
    numRecur = 0;
	global_memory = &(aContext.global_memory);
	markNode = aContext.markNode;
	markCell = aContext.markCell;
	global_mark = aContext.global_mark;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x40, %rdi
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
leaq 0x18(%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x2c(%r14)
movl $0x8c, %edx
xorl %esi, %esi
callq 0x20e0
movq %r15, 0xb0(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0xb8(%r14)
movq (%rbx), %rax
movq %rax, 0xc0(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0xc8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::~Backtrack()
Backtrack::~Backtrack()
{
	if( dag != NULL ) {
		delete dag;
		dag = NULL;
	}

	if( cs != NULL ) {
		delete cs;
		cs = NULL;
	}

	if( mapping != NULL ) {
		global_memory->returnLLArray(mapping, n2);
		mapping = NULL;
	}

	clearWorkspace();

	if( failingset != NULL ) {
		delete[] failingset;
		failingset = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x5e05
movq %r14, %rdi
callq 0x4758
movl $0x28, %esi
movq %r14, %rdi
callq 0x2190
movq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x5e2b
movq %r14, %rdi
callq 0x9100
movl $0x20, %esi
movq %r14, %rdi
callq 0x2190
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x5e4b
movq 0xb0(%rbx), %rdi
movl 0x34(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
callq 0x5ee8
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x5ead
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x5e91
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x5e8b
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2190
addq $-0x18, %r12
jne 0x5e75
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x2320
movq $0x0, 0x58(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x5ed3
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x31e1
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::clearWorkspace()
void Backtrack::clearWorkspace()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if( extCand != NULL ) {
		delete[] extCand;
		extCand = NULL;
	}
	if( heap != NULL ) {
		delete heap;
		heap = NULL;
	}
	if( weight != NULL ) {
		global_memory->returnLLArray(weight, n);
		weight = NULL;
	}
	if( numMappedParent != NULL ) {
		global_memory->returnLLArray(numMappedParent, n);
		numMappedParent = NULL;
	}
	if( candPos != NULL ) {
		global_memory->returnLLArray(candPos, n);
		candPos = NULL;
	}
	if( matchingOrder != NULL ) {
		global_memory->returnLLArray(matchingOrder, n);
		matchingOrder = NULL;
	}
	if( isBinary != NULL ) {
		global_memory->returnLLArray((int32_t*)isBinary, n);
		isBinary = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0x5f4d
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x5f31
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x5f2b
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2190
addq $-0x18, %r12
jne 0x5f15
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x2320
movq $0x0, 0x60(%rbx)
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0x5f73
movq %r14, %rdi
callq 0x915e
movl $0x18, %esi
movq %r14, %rdi
callq 0x2190
movq $0x0, 0x68(%rbx)
movq 0x70(%rbx), %rsi
testq %rsi, %rsi
je 0x5f93
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rsi
testq %rsi, %rsi
je 0x5fb3
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x78(%rbx)
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x5fd9
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x80(%rbx)
movq 0x88(%rbx), %rsi
testq %rsi, %rsi
je 0x5fff
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x88(%rbx)
movq 0x90(%rbx), %rsi
testq %rsi, %rsi
je 0x6025
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %edx
callq 0x4cf0
movq $0x0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::initWorkspace()
void Backtrack::initWorkspace()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	clearWorkspace();

	extCand = new vector<int32_t>[n];
	heap = new Heap(n);
	weight = global_memory->getLLArray(n);
	numMappedParent = global_memory->getLLArray(n);
	candPos = global_memory->getLLArray(n);
	matchingOrder = global_memory->getLLArray(n);
	isBinary = (char*)global_memory->getLLArray(n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5ee8
movl 0x2c(%rbx), %ebp
movslq %ebp, %r14
movl $0x18, %ecx
movq %r14, %rax
mulq %rcx
seto %cl
addq $0x8, %rax
movq $-0x1, %rdi
cmovbq %rdi, %rax
testb %cl, %cl
cmoveq %rax, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, (%rax)
addq $0x8, %r15
testl %r14d, %r14d
je 0x6321
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
movq %r15, 0x60(%rbx)
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x9104
movq %r14, 0x68(%rbx)
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %esi
callq 0x4b34
movq %rax, 0x70(%rbx)
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %esi
callq 0x4b34
movq %rax, 0x78(%rbx)
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %esi
callq 0x4b34
movq %rax, 0x80(%rbx)
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %esi
callq 0x4b34
movq %rax, 0x88(%rbx)
movq 0xb0(%rbx), %rdi
movl 0x2c(%rbx), %esi
callq 0x4b34
movq %rax, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::selectRoot()
int32_t Backtrack::selectRoot()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t root = 0;
	int32_t v, size;
	double value;
	double minValue = (double)n;
	char* one1 = g1->one;
	int32_t* d1 = g1->d;
	int32_t* perm = coloring->perm;
	int32_t* cellSize = coloring->cellSize;
	int32_t numNode = coloring->numNode;

	//for each cell
	for(int32_t i = 0; i < numNode; i += cellSize[i]) {
		size = cellSize[i];
		//for each element in the cell
		for(int32_t j = 0; j < size; ++j) {
			v = perm[i + j];
			if( v < n && one1[v] == 0 ) { //if v is in aG1
				value = size/((double)d1[v]);
				if( value < minValue ) {
					root = v;
					minValue = value;
				}
			} // if
		} //for (j)
	} //for (i)

	return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x7855
movl 0x2c(%rdi), %edx
movq 0x10(%rdi), %rdi
movq 0x20(%rdi), %rsi
movq 0x30(%rdi), %rdi
movq 0x10(%rax), %r8
movq 0x20(%rax), %r9
cvtsi2sd %edx, %xmm0
xorl %r10d, %r10d
xorl %eax, %eax
movslq %r10d, %rbx
movslq (%r9,%rbx,4), %r11
testq %r11, %r11
jle 0x7848
xorps %xmm1, %xmm1
cvtsi2sd %r11d, %xmm1
leaq (%r8,%rbx,4), %rbx
xorl %r14d, %r14d
movl (%rbx,%r14,4), %ebp
cmpl %edx, %ebp
jge 0x7840
movslq %ebp, %r15
cmpb $0x0, (%rdi,%r15)
jne 0x7840
xorps %xmm3, %xmm3
cvtsi2sdl (%rsi,%r15,4), %xmm3
movapd %xmm1, %xmm2
divsd %xmm3, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x7840
movapd %xmm2, %xmm0
movl %ebp, %eax
incq %r14
cmpq %r14, %r11
jne 0x7811
addl %r10d, %r11d
movl %r11d, %r10d
cmpl %ecx, %r11d
jl 0x77f6
jmp 0x7857
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::binarySearch(int*, int, int)
int32_t Backtrack::binarySearch(int32_t* aArray, int32_t aSize, int32_t aValue)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t l, r, m;

	//do linear search when aSize is small
	if( aSize < 10 ) { 
		for(l = 0; l < aSize; ++l) {
			if( aArray[l] == aValue )
				return l;
		}
		return -1;
	}

	//binary search
	l = 0;
	r = aSize - 1;
	while( l <= r ) {
		m = l + (r - l)/2;
		if( aArray[m] < aValue )
			l = m + 1;
		else if( aArray[m] > aValue )
			r = m - 1;
		else //aArray[m] == aValue
			return m;
	}
	return -1;
}

// Assembly:
cmpl $0x9, %edx
jg 0x787e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x787d
movl %edx, %edi
xorl %edx, %edx
cmpl %ecx, (%rsi,%rdx,4)
je 0x78b4
incq %rdx
cmpq %rdx, %rdi
jne 0x7870
retq
decl %edx
xorl %edi, %edi
movl %edx, %r8d
subl %edi, %r8d
movl %r8d, %eax
shrl $0x1f, %eax
addl %r8d, %eax
sarl %eax
addl %edi, %eax
movslq %eax, %r8
cmpl %ecx, (%rsi,%r8,4)
jge 0x78a4
incl %eax
movl %eax, %edi
jmp 0x78aa
jle 0x787d
decl %eax
movl %eax, %edx
cmpl %edx, %edi
jle 0x7882
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::getMinExtVertex()
int32_t Backtrack::getMinExtVertex()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if( heap->size == 0 ) {
		cout << "ERROR in " << __FUNCTION__ << "(): numExtVertex == 0" << endl;
		return -1;
	}
	return heap->extractMin(weight);
}

// Assembly:
movq %rdi, %rax
movq 0x68(%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x7be8
movq 0x70(%rax), %rsi
jmp 0x92fe
pushq %rbx
movq 0x83e0(%rip), %rbx      # 0xffd0
leaq 0x4778(%rip), %rsi      # 0xc36f
movl $0x9, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x476e(%rip), %rsi      # 0xc379
movl $0xf, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x476a(%rip), %rsi      # 0xc389
movl $0x15, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::Heap(int)
Heap::Heap(int32_t aSize)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	heap = new int32_t[aSize];
	locate = new int32_t[aSize];
	memset(locate, -1, sizeof(int32_t) * aSize);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq %esi, %rax
leaq (,%rax,4), %rbx
testl %eax, %eax
movq $-0x1, %r14
cmovnsq %rbx, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x0, 0x10(%rdi)
movq %r14, %rdi
callq 0x2030
movq %rax, (%r15)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x8(%r15)
movq %rax, %rdi
movl $0xff, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::~Heap()
Heap::~Heap()
{
	if( heap != NULL) {
		delete[] heap;
		heap = NULL;
	}
	if( locate != NULL) {
		delete[] locate;
		locate = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9176
callq 0x21f0
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x918c
callq 0x21f0
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::minHeapify(int*, int)
void Heap::minHeapify(int32_t* aValue, int32_t aIndex)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t l, r, s, t;
	int32_t i = aIndex;

	while(true) {
		s = i;	//smaller one's index
		l = LEFT(i);	//left child's index
		r = RIGHT(i);	//right child's index
		if( l <= size && aValue[heap[l]] < aValue[heap[s]] )
			s = l;
		if( r <= size && aValue[heap[r]] < aValue[heap[s]] )
			s = r;
		if( s != i ) { // if one of the children is smaller than i
			t = heap[s];
			heap[s] = heap[i];
			heap[i] = t;

			locate[ heap[s] ] = s;
			locate[ heap[i] ] = i;

			i = s;
		}
		else {
			break;
		}
	} //while(true)
}

// Assembly:
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leal (%rdx,%rdx), %r10d
movl 0x10(%rdi), %r11d
movslq %edx, %r8
movl %edx, %r9d
cmpl %r11d, %r10d
jg 0x91c6
movslq %r10d, %r9
movslq (%rax,%r9,4), %r9
movl (%rsi,%r9,4), %ebx
movslq (%rax,%r8,4), %r14
movl %r10d, %r9d
cmpl (%rsi,%r14,4), %ebx
jl 0x91c6
movl %edx, %r9d
cmpl %r11d, %r10d
jge 0x91f1
leal 0x1(,%rdx,2), %r10d
movslq %r10d, %r11
movslq (%rax,%r11,4), %r11
movl (%rsi,%r11,4), %r11d
movslq %r9d, %rbx
movslq (%rax,%rbx,4), %rbx
cmpl (%rsi,%rbx,4), %r11d
jl 0x91ee
movl %r9d, %r10d
movl %r10d, %r9d
cmpl %edx, %r9d
je 0x9221
movslq %r9d, %r10
movl (%rax,%r10,4), %r11d
movl (%rax,%r8,4), %ebx
movl %ebx, (%rax,%r10,4)
movl %r11d, (%rax,%r8,4)
movslq (%rax,%r10,4), %r10
movl %r9d, (%rcx,%r10,4)
movslq (%rax,%r8,4), %r8
movl %edx, (%rcx,%r8,4)
movl %r9d, %edx
jmp 0x9198
popq %rbx
popq %r14
retq
nop