LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2070
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x2a6b
movq 0x858a(%rip), %rdi      # 0xafd0
leaq 0x484c(%rip), %rsi      # 0x7299
callq 0x21d0
movq %rax, %rdi
movq 0x855c(%rip), %rsi      # 0xafb8
callq 0x21f0
movl $0x1, %edi
callq 0x2230
leaq -0x34(%rbp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x2120
movw $0x2, -0x34(%rbp)
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x2030
movw %ax, -0x32(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x34(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x2390
cmpl $0x0, %eax
jg 0x2ada
movq 0x851b(%rip), %rdi      # 0xafd0
leaq 0x47f8(%rip), %rsi      # 0x72b4
callq 0x21d0
movq %rax, %rdi
movq 0x84ed(%rip), %rsi      # 0xafb8
callq 0x21f0
movl $0x1, %edi
callq 0x2230
movq 0x84ef(%rip), %rdi      # 0xafd0
leaq 0x47f9(%rip), %rsi      # 0x72e1
callq 0x21d0
movq 0x84ec(%rip), %rdi      # 0xafe0
leaq -0x35(%rbp), %rsi
callq 0x2250
movl -0x24(%rbp), %edi
leaq -0x34(%rbp), %rsi
movl $0x10, %edx
callq 0x2170
cmpl $0x0, %eax
jge 0x2b3f
movq 0x84b6(%rip), %rdi      # 0xafd0
leaq 0x47ee(%rip), %rsi      # 0x730f
callq 0x21d0
movq %rax, %rdi
movq 0x8488(%rip), %rsi      # 0xafb8
callq 0x21f0
movl $0x1, %edi
callq 0x2230
movq 0x848a(%rip), %rdi      # 0xafd0
leaq 0x47d9(%rip), %rsi      # 0x7326
callq 0x21d0
movl -0x24(%rbp), %eax
movl %eax, 0x21755(%rip)     # 0x242b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x2260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x21b0
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x3f0(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x3ec(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x3f8(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: supragya[P]DirectorySync/DirectorySync.cpp
// Function: TransactionHistory_t::TransactionHistory_t()
TransactionHistory_t(){
        for(int i=0; i<MAXTRANSACTIONS; i++){
            ValidTransactionHistory[i] = false;
            strcpy(TransactionHistory[i].FileName, "");
            TransactionHistory[i].FCType = FCT_NONE;
            TransactionHistory[i].FType = FT_NONE;
            TransactionHistory[i].FileSize = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x19068, %rdi          # imm = 0x19068
callq 0x5280
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x49b0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movb $0x0, (%rdi,%rax)
addq $0x68, %rdi
movslq -0xc(%rbp), %rax
shlq $0xa, %rax
addq %rax, %rdi
addq $0x4, %rdi
leaq 0x30c1(%rip), %rsi      # 0x7a08
callq 0x21b0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movslq -0xc(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
movl $0x0, 0x3ec(%rcx)
movq %rax, %rcx
addq $0x68, %rcx
movslq -0xc(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
movl $0x0, 0x3f0(%rcx)
addq $0x68, %rax
movslq -0xc(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq $0x0, 0x3f8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4917
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: supragya[P]DirectorySync/DirectorySync.cpp
// Function: TransactionHistory_t::already_processed(message)
bool already_processed(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;
                break;
            }
        }
        mtx.unlock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x19068, %rdi          # imm = 0x19068
callq 0x5000
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x64, -0x10(%rbp)
jge 0x4df0
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x4d40
jmp 0x4de2
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
addq $0x68, %rsi
movslq -0x10(%rbp), %rax
shlq $0xa, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2290
cmpl $0x0, %eax
jne 0x4de0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x3f0(%rax), %eax
addq $0x68, %rcx
movslq -0x10(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
cmpl 0x3f0(%rcx), %eax
jne 0x4de0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x3f8(%rax), %rax
addq $0x68, %rcx
movslq -0x10(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
cmpq 0x3f8(%rcx), %rax
jne 0x4de0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x3ec(%rax), %eax
addq $0x68, %rcx
movslq -0x10(%rbp), %rdx
shlq $0xa, %rdx
addq %rdx, %rcx
cmpl 0x3ec(%rcx), %eax
jne 0x4de0
movb $0x1, -0x9(%rbp)
jmp 0x4df0
jmp 0x4de2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d23
movq -0x18(%rbp), %rdi
addq $0x19068, %rdi          # imm = 0x19068
callq 0x5030
ud2
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: supragya[P]DirectorySync/DirectorySync.cpp
// Function: TransactionHistory_t::record_message(message)
bool record_message(message m){
        mtx.lock();
        bool RecordingSuccess = false;
        int i = 0;
        while(!RecordingSuccess && i<MAXTRANSACTIONS){
            if(ValidTransactionHistory[i]){
                i++;
                continue;
            }
            else{
                strcpy(TransactionHistory[i].FileName, m.FileName);
                TransactionHistory[i].FCType = m.FCType;
                TransactionHistory[i].FileSize = m.FileSize;
                TransactionHistory[i].FType = m.FType;
                ValidTransactionHistory[i] = true;
                RecordingSuccess = true;
                break;
            }
        }
        mtx.unlock();
        return RecordingSuccess;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x19068, %rdi          # imm = 0x19068
callq 0x5000
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x21(%rbp)
jne 0x4e58
cmpl $0x64, -0x10(%rbp)
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4e64
jmp 0x4f11
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x4e7d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4e43
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x68, %rdi
movslq -0x10(%rbp), %rax
shlq $0xa, %rax
addq %rax, %rdi
addq $0x4, %rdi
addq $0x4, %rsi
callq 0x21b0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x3ec(%rcx), %esi
movq %rax, %rdx
addq $0x68, %rdx
movslq -0x10(%rbp), %rdi
shlq $0xa, %rdi
addq %rdi, %rdx
movl %esi, 0x3ec(%rdx)
movq 0x3f8(%rcx), %rsi
movq %rax, %rdx
addq $0x68, %rdx
movslq -0x10(%rbp), %rdi
shlq $0xa, %rdi
addq %rdi, %rdx
movq %rsi, 0x3f8(%rdx)
movl 0x3f0(%rcx), %edx
movq %rax, %rcx
addq $0x68, %rcx
movslq -0x10(%rbp), %rsi
shlq $0xa, %rsi
addq %rsi, %rcx
movl %edx, 0x3f0(%rcx)
movslq -0x10(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movb $0x1, -0x9(%rbp)
movq -0x18(%rbp), %rdi
addq $0x19068, %rdi          # imm = 0x19068
callq 0x5030
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20c0
movq %rax, %rdi
leaq 0xbb6e(%rip), %rsi      # 0xe080
callq 0x2270
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2561
movq 0x13aad(%rip), %rax     # 0x15fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0xbb37(%rip), %rsi      # 0xe083
movb $0x0, %al
callq 0x22c0
movq $0x0, 0x40(%rsp)
jmp 0x2626
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2240
movq 0x28(%rsp), %rdi
callq 0x2030
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2240
movq 0x30(%rsp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x22b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x28(%rsp), %rcx
movl $0x1, %edx
callq 0x22f0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21d0
cmpq $0x1, 0x18(%rsp)
je 0x261c
movq 0x139ef(%rip), %rax     # 0x15fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0xba93(%rip), %rsi      # 0xe09d
movb $0x0, %al
callq 0x22c0
movq $0x0, 0x40(%rsp)
jmp 0x2626
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x30(%rsp), %rsi
leaq 0xa847(%rip), %rdi      # 0xe0fa
movb $0x0, %al
callq 0x2050
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x2c(%rsp), %ecx
cmpq %rcx, %rax
jae 0x38ef
leaq 0xa830(%rip), %rdi      # 0xe108
movb $0x0, %al
callq 0x2050
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x38c3
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6c50
testb $0x1, %al
jne 0x3904
jmp 0x3926
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa79c(%rip), %rsi      # 0xe0b9
callq 0x6c50
testb $0x1, %al
jne 0x3939
leaq 0xa7e8(%rip), %rdi      # 0xe115
movb $0x0, %al
callq 0x2050
jmp 0x3a58
leaq 0xa776(%rip), %rax      # 0xe0b6
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa760(%rip), %rsi      # 0xe0be
callq 0x6c50
testb $0x1, %al
jne 0x3969
jmp 0x3994
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa73c(%rip), %rsi      # 0xe0be
callq 0x6ca0
movq %rax, %rdi
callq 0x6cd0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa702(%rip), %rsi      # 0xe0b9
callq 0x6ca0
movq %rax, %rdi
callq 0x6cd0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0xa754(%rip), %rdi      # 0xe127
movb $0x0, %al
callq 0x2050
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa71a(%rip), %rsi      # 0xe10d
callq 0x6c50
testb $0x1, %al
jne 0x39fe
jmp 0x3a58
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6ca0
movq %rax, %rdi
leaq 0xa6d9(%rip), %rsi      # 0xe10d
callq 0x6ca0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
addl $0x1, %r8d
callq 0x3390
addq $0x48, %rsp
retq
nopl (%rax)
// File: shininglion[P]find_max_independent_set/./mis.cpp
// Function: bool graph::validateMIS<std::vector<Node, std::allocator<Node>>, main::$_2>(std::vector<Node, std::allocator<Node>> const&, std::vector<int, std::allocator<int>> const&, main::$_2)
bool validateMIS(const T& graph, const std::vector<int>& mis, EdgeExtractor edge_extractor)
	{
		bool pass = true;
		for (size_t i = 0; pass && (i < mis.size()); ++i) {
			for (size_t j = i + 1; j < mis.size(); ++j) {
				auto& edge_list = edge_extractor( graph[ mis[j] ] );

				bool check = false;
				for (auto& edge : edge_list) {
					if (edge == mis[i]) { check = true; break; }
				}
				if (check) { pass = false; break; }
			}
		}
		return pass;
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movb $0x1, 0x6f(%rsp)
movq $0x0, 0x60(%rsp)
xorl %eax, %eax
testb $0x1, 0x6f(%rsp)
movb %al, 0x27(%rsp)
je 0x1b72
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x28c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x1b7f
jmp 0x1cb0
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0x28c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c9b
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x6e50
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x4fc0
movq %rax, %rsi
leaq 0x87(%rsp), %rdi
callq 0x2570
movq %rax, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4fe0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5010
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5040
testb $0x1, %al
jne 0x1c2f
jmp 0x1c78
leaq 0x38(%rsp), %rdi
callq 0x5080
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x6e50
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jne 0x1c6a
movb $0x1, 0x4f(%rsp)
jmp 0x1c78
jmp 0x1c6c
leaq 0x38(%rsp), %rdi
callq 0x5110
jmp 0x1c1a
testb $0x1, 0x4f(%rsp)
je 0x1c86
movb $0x0, 0x6f(%rsp)
jmp 0x1c9b
jmp 0x1c88
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x1b8d
jmp 0x1c9d
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x1b3f
movb 0x6f(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
nop
// File: 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 %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x11df
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x11f7
movl $0x0, -0x4(%rbp)
jmp 0x1204
movl -0x1c(%rbp), %eax
cltd
idivl -0x10(%rbp)
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: SNUCSE-CTA[P]GI/src/program.cpp
// Function: printExample()
void printExample() 
{
	cout << "*******************************" << endl;
	cout << "iGraph format example: Triangle" << endl;
	cout << "*******************************" << endl;
	cout << "t 0 3" << endl;
	cout << "v 0 20" << endl;
	cout << "v 0 10" << endl;
	cout << "v 0 14" << endl;
	cout << "e 0 1 0" << endl;
	cout << "e 0 2 0" << endl;
	cout << "e 1 2 0" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1c4f5(%rip), %rdi     # 0x1ffd0
leaq 0x14623(%rip), %rsi     # 0x18105
callq 0x31b0
movq %rax, %rdi
movq 0x1c4c7(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c4d3(%rip), %rdi     # 0x1ffd0
leaq 0x14621(%rip), %rsi     # 0x18125
callq 0x31b0
movq %rax, %rdi
movq 0x1c4a5(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c4b1(%rip), %rdi     # 0x1ffd0
leaq 0x145df(%rip), %rsi     # 0x18105
callq 0x31b0
movq %rax, %rdi
movq 0x1c483(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c48f(%rip), %rdi     # 0x1ffd0
leaq 0x145fd(%rip), %rsi     # 0x18145
callq 0x31b0
movq %rax, %rdi
movq 0x1c461(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c46d(%rip), %rdi     # 0x1ffd0
leaq 0x145e1(%rip), %rsi     # 0x1814b
callq 0x31b0
movq %rax, %rdi
movq 0x1c43f(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c44b(%rip), %rdi     # 0x1ffd0
leaq 0x145c6(%rip), %rsi     # 0x18152
callq 0x31b0
movq %rax, %rdi
movq 0x1c41d(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c429(%rip), %rdi     # 0x1ffd0
leaq 0x145ab(%rip), %rsi     # 0x18159
callq 0x31b0
movq %rax, %rdi
movq 0x1c3fb(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c407(%rip), %rdi     # 0x1ffd0
leaq 0x14590(%rip), %rsi     # 0x18160
callq 0x31b0
movq %rax, %rdi
movq 0x1c3d9(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c3e5(%rip), %rdi     # 0x1ffd0
leaq 0x14576(%rip), %rsi     # 0x18168
callq 0x31b0
movq %rax, %rdi
movq 0x1c3b7(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movq 0x1c3c3(%rip), %rdi     # 0x1ffd0
leaq 0x1455c(%rip), %rsi     # 0x18170
callq 0x31b0
movq %rax, %rdi
movq 0x1c395(%rip), %rsi     # 0x1ffb8
callq 0x31e0
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4a80
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movslq -0x10(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3110
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x10(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3110
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, 0x10(%rax)
cmpq $0x0, (%rax)
je 0x4ac6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4abb
movq -0x18(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4af8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4aec
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x6582
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6576
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x65b4
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x65a8
movq -0x28(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x65e6
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x65da
movq -0x30(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x6670
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x6649
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x663c
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x663a
movq -0x38(%rbp), %rdi
callq 0x3280
jmp 0x663c
jmp 0x663e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x65f8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x6664
movq -0x40(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x66a2
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x6696
movq -0x48(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x6822
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6816
movq -0x18(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6854
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6848
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6886
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x687a
movq -0x28(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x7ad0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7794
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7af0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7787
movq -0x28(%rbp), %rdi
callq 0x3280
jmp 0x7789
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x774b
movq -0x18(%rbp), %rdi
callq 0x7b10
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x7b30
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x7b50
movq -0x18(%rbp), %rdi
callq 0x7bb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x49c0
movq -0x1b0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x13b30
movq -0x1a8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13df0
movb %al, -0x199(%rbp)
jmp 0x9bda
movb -0x199(%rbp), %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9c22
movb $0x0, -0x1(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x9da4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x9dbe
leaq -0xa8(%rbp), %rdi
callq 0x165f0
movq %rax, -0x1b8(%rbp)
jmp 0x9c37
movq -0x1b0(%rbp), %rax
movq -0x1b8(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movq (%rax), %rsi
leaq -0x198(%rbp), %rdi
callq 0xbc30
jmp 0x9c5d
movq -0xc8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x16610
movl %eax, -0x1bc(%rbp)
jmp 0x9c95
movl -0x1bc(%rbp), %r8d
movq -0x1c8(%rbp), %rcx
movq -0x1d0(%rbp), %rdx
movq -0x1d8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0xc160
movb %al, -0x1d9(%rbp)
jmp 0x9cc5
movb -0x1d9(%rbp), %al
andb $0x1, %al
movb %al, -0xa9(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xc0e0
movsd %xmm0, -0x1e8(%rbp)
jmp 0x9ce9
movsd -0x1e8(%rbp), %xmm0
movq -0x1b0(%rbp), %rdi
callq 0x9af0
leaq -0x198(%rbp), %rdi
callq 0xc100
movl %eax, -0x1ec(%rbp)
jmp 0x9d11
movl -0x1ec(%rbp), %esi
movq -0x1b0(%rbp), %rdi
callq 0x9b10
testb $0x1, -0xa9(%rbp)
je 0x9d72
movq -0x1b0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x148(%rbp), %rcx
movq -0xc8(%rbp), %r8
callq 0x9de0
jmp 0x9d50
jmp 0x9d72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xbd70
jmp 0x9dbe
movq -0x1b0(%rbp), %rax
movq (%rax), %rdi
callq 0x4a80
jmp 0x9d83
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0xc0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xbd70
leaq -0xa8(%rbp), %rdi
callq 0x13c10
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0xa8(%rbp), %rdi
callq 0x13c10
movq -0xb8(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x240(%rbp)
movl $0x10, %edx
callq 0x3210
movq -0x240(%rbp), %rdi
leaq 0xe08c(%rip), %rsi      # 0x1836c
callq 0x31b0
movq %rax, -0x238(%rbp)
jmp 0xa2ee
movq -0x238(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31b0
movq %rax, -0x250(%rbp)
jmp 0xa307
movq -0x250(%rbp), %rdi
leaq 0xe053(%rip), %rsi      # 0x18368
callq 0x31b0
movq %rax, -0x258(%rbp)
jmp 0xa323
movq -0x258(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31b0
movq %rax, -0x260(%rbp)
jmp 0xa33c
movq -0x260(%rbp), %rdi
leaq 0xdceb(%rip), %rsi      # 0x18035
callq 0x31b0
movq %rax, -0x268(%rbp)
jmp 0xa358
movq -0x268(%rbp), %rdi
movq 0x15c52(%rip), %rsi     # 0x1ffb8
callq 0x31e0
jmp 0xa36d
movl $0x0, -0x230(%rbp)
movq -0x248(%rbp), %rcx
movl -0x230(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0xa439
movl -0x230(%rbp), %esi
leaq -0x220(%rbp), %rdi
callq 0x3350
movq %rax, -0x270(%rbp)
jmp 0xa3a8
movq -0x270(%rbp), %rdi
leaq 0xdc8e(%rip), %rsi      # 0x18044
callq 0x31b0
movq %rax, -0x278(%rbp)
jmp 0xa3c4
movq -0x278(%rbp), %rdi
movq -0x248(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x230(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x3350
movq %rax, -0x280(%rbp)
jmp 0xa3ee
movq -0x280(%rbp), %rdi
movq 0x15bbc(%rip), %rsi     # 0x1ffb8
callq 0x31e0
jmp 0xa403
jmp 0xa405
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
jmp 0xa377
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x32e0
jmp 0xa45c
leaq -0x220(%rbp), %rdi
callq 0x32c0
jmp 0xa447
leaq -0x220(%rbp), %rdi
callq 0x32e0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3370
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movl $0x0, 0x30(%rdi)
movl $0x0, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
movq $0x0, 0x58(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x68(%rdi)
movq $0x0, 0x70(%rdi)
movq $0x0, 0x78(%rdi)
movq $0x0, 0x80(%rdi)
movq $0x0, 0x88(%rdi)
movq $0x0, 0x90(%rdi)
addq $0x98, %rdi
callq 0x108c0
movq -0x18(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movl $0x0, 0xc8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq %rcx, 0xb0(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0xc8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x40(%rax)
je 0xbdc0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbdb4
movq -0x18(%rbp), %rdi
callq 0x67b0
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xbe00
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbdf4
movq -0x20(%rbp), %rdi
callq 0x13640
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xbe30
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x50(%rax), %rsi
movl 0x34(%rax), %edx
callq 0x7a30
jmp 0xbe24
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0xbef0
jmp 0xbe3b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xbec5
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbeb9
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
imulq $0x18, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x30(%rbp)
je 0xbea4
movq -0x30(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x108e0
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0xbe82
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
imulq $0x18, %rax, %rsi
addq $0x8, %rsi
callq 0x33c0
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x108e0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4400
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x60(%rax)
je 0xbf8a
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbf7e
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x28(%rbp)
imulq $0x18, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x20(%rbp)
je 0xbf69
movq -0x20(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x108e0
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0xbf47
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
imulq $0x18, %rax, %rsi
addq $0x8, %rsi
callq 0x33c0
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xbfca
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbfbe
movq -0x40(%rbp), %rdi
callq 0x13700
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0xbff8
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x70(%rax), %rsi
movl 0x2c(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0xc026
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x78(%rax), %rsi
movl 0x2c(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0xc05d
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x80(%rax), %rsi
movl 0x2c(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xc094
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x88(%rax), %rsi
movl 0x2c(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0xc0cb
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
movq 0x90(%rax), %rsi
movl 0x2c(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xbef0
movq -0x30(%rbp), %rax
movslq 0x2c(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc5c3
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x108c0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0xc5a1
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x18, %edi
callq 0x31c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movl 0x2c(%rax), %esi
callq 0x13650
jmp 0xc5f1
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq 0xb0(%rax), %rdi
movl 0x2c(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x70(%rax)
movq 0xb0(%rax), %rdi
movl 0x2c(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x78(%rax)
movq 0xb0(%rax), %rdi
movl 0x2c(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x80(%rax)
movq 0xb0(%rax), %rdi
movl 0x2c(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x88(%rax)
movq 0xb0(%rax), %rdi
movl 0x2c(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x90(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x31d0
movq -0x10(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0xc(%rbp)
cvtsi2sdl 0x2c(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, -0x38(%rbp)
movq 0x20(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x20(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, -0x48(%rbp)
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0xe50f
movq -0x48(%rbp), %rax
movslq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xe4f7
movq -0x60(%rbp), %rcx
movq -0x40(%rbp), %rax
movl -0x50(%rbp), %edx
addl -0x54(%rbp), %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0xe4e7
movq -0x30(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xe4e7
cvtsi2sdl -0x14(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe4e5
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xe4e7
jmp 0xe4e9
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xe472
jmp 0xe4f9
movq -0x48(%rbp), %rax
movslq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0xe451
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0xe618
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe60f
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jne 0xe602
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe697
jmp 0xe604
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe5df
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe697
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0xe690
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jge 0xe669
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe68e
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jle 0xe684
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe68c
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe697
jmp 0xe68e
jmp 0xe628
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x68(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0xec07
movq 0x1140b(%rip), %rdi     # 0x1ffd0
leaq 0x97a3(%rip), %rsi      # 0x1836f
callq 0x31b0
movq %rax, %rdi
leaq 0x979e(%rip), %rsi      # 0x18379
callq 0x31b0
movq %rax, %rdi
leaq 0x979f(%rip), %rsi      # 0x18389
callq 0x31b0
movq %rax, %rdi
movq 0x113bf(%rip), %rsi     # 0x1ffb8
callq 0x31e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec1b
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
callq 0x13a90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)