LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetBPC(char, char, char)
bool MSR::SetBPC(char Track1, char Track2, char Track3) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to set BPC, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[5];
		char expt[5];
		char bpc_data[5];

		memcpy(bpc_data, (void*)MSR_SET_BPC, 2);
		memcpy(&bpc_data[2], (void*)&Track1, 1);
		memcpy(&bpc_data[3], (void*)&Track2, 1);
		memcpy(&bpc_data[4], (void*)&Track3, 1);

		memcpy(bpc_data, expt, 5);
		memcpy(&expt[0], MSR_OK, 2);

		this->WriteBytes(bpc_data, 5);
		if(this->ReadBytes(resp, 5) != 5) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set BPC, expected 5 bytes" << std::endl;
#endif
			return false;
		}

		if(memcmp(resp, expt, 5) != 0) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set BPC, unexpected response" << std::endl;
#endif
			return false;
		}

		return true;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x4(%rax)
jne 0x6dd3
movb $0x0, -0x1(%rbp)
jmp 0x6e57
movq -0x30(%rbp), %rdi
movw 0x2344(%rip), %ax       # 0x9122
movw %ax, -0x22(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x20(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1f(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x1e(%rbp)
movl -0x1d(%rbp), %eax
movl %eax, -0x22(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1e(%rbp)
movw 0x22f2(%rip), %ax       # 0x90f9
movw %ax, -0x1d(%rbp)
leaq -0x22(%rbp), %rsi
movl $0x5, %edx
callq 0x5140
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0x5160
cmpl $0x5, %eax
je 0x6e36
movb $0x0, -0x1(%rbp)
jmp 0x6e57
leaq -0x18(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x5, %edx
callq 0x51f0
cmpl $0x0, %eax
je 0x6e53
movb $0x0, -0x1(%rbp)
jmp 0x6e57
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetCoercivity(lib605::MSR::COERCIVITY)
bool MSR::SetCoercivity(COERCIVITY co) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to set Coercivity, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[2];
		switch(co) {
			case HI_CO: {
				this->WriteAutoSize(MSR_SET_HI_CO);
				break;
			} case LO_CO: {
				this->WriteAutoSize(MSR_SET_LO_CO);
				break;
			} default: break;
		}
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set Coercivity, expected 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x7013
movb $0x0, -0x1(%rbp)
jmp 0x708c
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x7029
jmp 0x701f
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x703b
jmp 0x704d
movq -0x20(%rbp), %rdi
leaq 0x2109(%rip), %rsi      # 0x913d
callq 0x5240
jmp 0x704f
movq -0x20(%rbp), %rdi
leaq 0x20ad(%rip), %rsi      # 0x90f3
callq 0x5240
jmp 0x704f
jmp 0x704f
movq -0x20(%rbp), %rdi
leaq -0x16(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x706c
movb $0x0, -0x1(%rbp)
jmp 0x708c
leaq -0x16(%rbp), %rax
movw (%rax), %ax
subw $0x301b, %ax            # imm = 0x301B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7088
movb $0x1, -0x1(%rbp)
jmp 0x708c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetCoercivity()
MSR::COERCIVITY MSR::GetCoercivity(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get Coercivity, not connect to device" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
		char resp[2];
		this->WriteAutoSize(MSR_GET_CO_STAT);
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to get Coercivity, expected 2 bytes" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
		if(memcmp(resp, MSR_ESC "H", 2) == 0) {
			return MSR::COERCIVITY::HI_CO;
		} else if(memcmp(resp, MSR_ESC "L", 2) == 0) {
			return MSR::COERCIVITY::LO_CO;
		} else {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to get Coercivity, unexpected value" << std::endl;
#endif
			return MSR::COERCIVITY::ERR;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x70c3
movl $0x2, -0x4(%rbp)
jmp 0x7138
movq -0x20(%rbp), %rdi
leaq 0x2072(%rip), %rsi      # 0x9140
callq 0x5240
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x70f3
movl $0x2, -0x4(%rbp)
jmp 0x7138
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x481b, %ax            # imm = 0x481B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7112
movl $0x0, -0x4(%rbp)
jmp 0x7138
leaq -0x12(%rbp), %rax
movw (%rax), %ax
subw $0x4c1b, %ax            # imm = 0x4C1B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7131
movl $0x1, -0x4(%rbp)
jmp 0x7138
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::SetLeadingZero(unsigned char, unsigned char)
bool MSR::SetLeadingZero(unsigned char Track1_3, unsigned char Track2) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to Set leading zero, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[2];
		char zero_dat[4];

		memcpy(zero_dat, (void*)MSR_SET_LEAD_ZERO, 2);
		memcpy(&zero_dat[2], (void*)&Track1_3, 1);
		memcpy(&zero_dat[3], (void*)&Track2, 1);

		this->WriteBytes(zero_dat, 4);
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set leading zero, expected 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4(%rax)
jne 0x717b
movb $0x0, -0x1(%rbp)
jmp 0x71e1
movq -0x20(%rbp), %rdi
movw 0x1fc3(%rip), %ax       # 0x9149
movw %ax, -0x18(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x16(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x15(%rbp)
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x5140
movq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x71c1
movb $0x0, -0x1(%rbp)
jmp 0x71e1
leaq -0x14(%rbp), %rax
movw (%rax), %ax
subw $0x301b, %ax            # imm = 0x301B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x71dd
movb $0x1, -0x1(%rbp)
jmp 0x71e1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::GetLeadZero()
std::tuple<unsigned char, unsigned char> MSR::GetLeadZero(void) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, not connect to device" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		char resp[3];
		this->WriteAutoSize(MSR_CHECK_LEAD_ZERO);
		if(this->ReadBytes(resp, 3) != 3) {
#if defined(DEBUG)
			std::cout << "[*] Unable to get leading zero, expected 3 bytes" << std::endl;
#endif
			return std::make_tuple(0x00, 0x00);
		}
		return std::make_tuple(resp[1], resp[2]);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x4(%rax)
jne 0x7247
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5500
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x55a0
jmp 0x72c2
movq -0x40(%rbp), %rdi
leaq 0x1efa(%rip), %rsi      # 0x914c
callq 0x5240
movq -0x40(%rbp), %rdi
leaq -0x23(%rbp), %rsi
movl $0x3, %edx
callq 0x5160
cmpl $0x3, %eax
je 0x729c
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x5500
movq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x55a0
jmp 0x72c2
leaq -0x23(%rbp), %rsi
addq $0x1, %rsi
leaq -0x23(%rbp), %rdx
addq $0x2, %rdx
leaq -0x36(%rbp), %rdi
callq 0x53a0
movq -0x50(%rbp), %rdi
leaq -0x36(%rbp), %rsi
callq 0x5730
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: geoherna[P]lib605/./src/lib605.cpp
// Function: lib605::MSR::EraseCard(lib605::MSR::TRACK)
bool MSR::EraseCard(MSR::TRACK track) {
		if(!this->MSRConected) {
#if defined(DEBUG)
			std::cout << "[*] Unable to set erase mode, not connect to device" << std::endl;
#endif
			return false;
		}
		char resp[2];
		char erase_dat[3];

		memcpy(erase_dat, MSR_ERASE_CARD, 2);
		switch(track) {
			case MSR::TRACK::TRACK_1: {
				memcpy(&erase_dat[2], MSR_EC_TRACK1, 1);
				break;
			} case MSR::TRACK::TRACK_2: {
				memcpy(&erase_dat[2], MSR_EC_TRACK2, 1);
				break;
			} case MSR::TRACK::TRACK_3: {
				memcpy(&erase_dat[2], MSR_EC_TRACK3, 1);
				break;
			} case MSR::TRACK::TRACK_1_2: {
				memcpy(&erase_dat[2], MSR_EC_TRACK1_2, 1);
				break;
			} case MSR::TRACK::TRACK_1_3: {
				memcpy(&erase_dat[2], MSR_EC_TRACK1_3, 1);
				break;
			} case MSR::TRACK::TRACK_2_3: {
				memcpy(&erase_dat[2], MSR_EC_TRACK2_3, 1);
				break;
			} case MSR::TRACK::TRACK_1_2_3: {
				memcpy(&erase_dat[2], MSR_EC_TRACK1_2_3, 1);
				break;
			} default: break;
		}
		this->WriteBytes(erase_dat, 3);
		if(this->ReadBytes(resp, 2) != 2) {
#if defined(DEBUG)
			std::cout << "[*] Error: Unable to set erase, expected 2 bytes" << std::endl;
#endif
			return false;
		}
		if(memcmp(resp, MSR_OK, 2) == 0) {
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x4(%rax)
jne 0x72f6
movb $0x0, -0x1(%rbp)
jmp 0x73bb
movw $0x6c1b, -0x1a(%rbp)    # imm = 0x6C1B
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x736a
movq -0x30(%rbp), %rax
leaq 0x1d00(%rip), %rcx      # 0x9014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x1d0d(%rip), %al       # 0x9030
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1e21(%rip), %al       # 0x914f
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1e18(%rip), %al       # 0x9151
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1e0f(%rip), %al       # 0x9153
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1e06(%rip), %al       # 0x9155
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1dfd(%rip), %al       # 0x9157
movb %al, -0x18(%rbp)
jmp 0x736c
movb 0x1df4(%rip), %al       # 0x9159
movb %al, -0x18(%rbp)
jmp 0x736c
jmp 0x736c
movq -0x28(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movl $0x3, %edx
callq 0x5140
movq -0x28(%rbp), %rdi
leaq -0x16(%rbp), %rsi
movl $0x2, %edx
callq 0x5160
cmpl $0x2, %eax
je 0x739b
movb $0x0, -0x1(%rbp)
jmp 0x73bb
leaq -0x16(%rbp), %rax
movw (%rax), %ax
subw $0x301b, %ax            # imm = 0x301B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x73b7
movb $0x1, -0x1(%rbp)
jmp 0x73bb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AutomataLab[P]JSONSki/example/example3.cpp
// Function: main
int main() {
    char* file_path = "../dataset/twitter_sample_small_records.json";
    RecordSet* record_set = RecordLoader::loadRecords(file_path);
    if (record_set->size() == 0) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$.entities.urls[*].url");
    int num_recs = record_set->size();
    for (int i = 0; i < num_recs; i++) {
        string output = processor.runQuery((*record_set)[i]);
        cout<<"matches are: "<<output<<endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xf000, %rsp           # imm = 0xF000
movl $0x0, 0xefec(%rsp)
leaq 0x9f996(%rip), %rax     # 0x103107
movq %rax, 0xefe0(%rsp)
movq 0xefe0(%rsp), %rdi
callq 0x62990
movq %rax, 0xefd8(%rsp)
movq 0xefd8(%rsp), %rdi
callq 0x63990
cmpq $0x0, %rax
jne 0x637d3
leaq 0xdacd8(%rip), %rdi     # 0x13e480
leaq 0x9f985(%rip), %rsi     # 0x103134
callq 0xccc00
movq %rax, %rdi
leaq 0x68d22(%rip), %rsi     # 0xcc4e0
callq 0xcb6f0
movl $0xffffffff, 0xefec(%rsp) # imm = 0xFFFFFFFF
jmp 0x6397a
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x64a30
movq 0x38(%rsp), %rdx
leaq 0x9f95c(%rip), %rsi     # 0x10314a
leaq 0x80(%rsp), %rdi
callq 0xd5a00
jmp 0x637fd
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x16b10
jmp 0x63814
leaq 0x80(%rsp), %rdi
callq 0xd2fd0
leaq 0x7f(%rsp), %rdi
callq 0x64a50
movq 0xefd8(%rsp), %rdi
callq 0x63990
movq %rax, 0x30(%rsp)
jmp 0x6383f
movq 0x30(%rsp), %rax
movl %eax, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x63951
movq 0xefd8(%rsp), %rdi
movslq 0x64(%rsp), %rsi
callq 0x639a0
movq %rax, 0x28(%rsp)
jmp 0x63877
movq 0x28(%rsp), %rax
movq (%rax), %rdx
leaq 0x40(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x621f0
jmp 0x63893
leaq 0xdabe6(%rip), %rdi     # 0x13e480
leaq 0x9f8c0(%rip), %rsi     # 0x103161
callq 0xccc00
movq %rax, 0x20(%rsp)
jmp 0x638ad
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd5ad0
movq %rax, 0x18(%rsp)
jmp 0x638c3
movq 0x18(%rsp), %rdi
leaq 0x68c11(%rip), %rsi     # 0xcc4e0
callq 0xcb6f0
jmp 0x638d6
leaq 0x40(%rsp), %rdi
callq 0xd2fd0
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x63850
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x6391b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd2fd0
leaq 0x7f(%rsp), %rdi
callq 0x64a50
jmp 0x63986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x6396b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd2fd0
jmp 0x6396b
movl $0x0, 0xefec(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x18ac0
jmp 0x6397a
leaq 0xa0(%rsp), %rdi
callq 0x18ac0
jmp 0x63986
movl 0xefec(%rsp), %eax
movq %rbp, %rsp
popq %rbp
retq
movq 0x70(%rsp), %rdi
callq 0x13720
// File: AutomataLab[P]JSONSki/example/../src/lib/Records.h
// Function: RecordSet::operator[](long)
Record*& operator[] (long idx) {
        if (idx >= 0 && idx < num_recs)
            return recs[idx];
        cout << "Array index in RecordSet out of bound."<<endl; 
        exit(0); 
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0x639e1
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x18(%rcx), %rax
jge 0x639e1
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x62e90
addq $0x18, %rsp
retq
leaq 0xdaa98(%rip), %rdi     # 0x13e480
leaq 0x9f780(%rip), %rsi     # 0x10316f
callq 0xccc00
movq %rax, %rdi
leaq 0x68ae2(%rip), %rsi     # 0xcc4e0
callq 0xcb6f0
xorl %edi, %edi
callq 0x131b0
nopw (%rax,%rax)
// File: flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: testBGL(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS>, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::vector<int> testBGL (graph_t g, vertex_descriptor s, std::vector<vertex_descriptor> &p)
{
	
	// Keeps track of the predecessor of each vertex
	//std::vector<vertex_descriptor> p(num_vertices(g));
	// Keeps track of the distance to each vertex
	std::vector<int> d(num_vertices(g));



	boost::dijkstra_shortest_paths(g, s,
		predecessor_map(
	     make_iterator_property_map(p.begin(), get(vertex_index, g))).
	   distance_map(
	     make_iterator_property_map(d.begin(), get(vertex_index, g)))
	   );
	
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xe0(%rbp)
movq %rdi, %rax
movq -0xe0(%rbp), %rdi
movq %rax, -0xd0(%rbp)
movq %rax, %rsi
movq %rsi, -0xd8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xae10
movq %rax, -0xc8(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xae50
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0xae70
jmp 0x4d29
leaq -0x22(%rbp), %rdi
callq 0xaee0
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb010
movq -0xe0(%rbp), %rsi
movq %rax, -0x90(%rbp)
xorl %edi, %edi
callq 0xb040
jmp 0x4d5d
movq -0x90(%rbp), %rdi
callq 0xafe0
movq %rax, -0xf0(%rbp)
jmp 0x4d72
movq -0xf0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xafa0
jmp 0x4d92
movq -0xd0(%rbp), %rdi
callq 0xb0f0
movq -0xe0(%rbp), %rsi
movq %rax, -0xb0(%rbp)
xorl %edi, %edi
callq 0xb040
jmp 0x4db5
movq -0xb0(%rbp), %rdi
callq 0xb0c0
movq %rax, -0xf8(%rbp)
jmp 0x4dca
movq -0xf8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0xb070
jmp 0x4dee
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xaf00
jmp 0x4e07
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x4e50
jmp 0x4e44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0xaee0
jmp 0x4e60
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb120
jmp 0x4e60
movq -0xd0(%rbp), %rdi
callq 0xb120
movq -0xd8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4520
nopl (%rax)
// File: flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: timed_dijkstra(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS>, unsigned long)
float timed_dijkstra(graph_t g, vertex_descriptor s)
{
	predecessor_map_t p;
	auto startTime = chrono::high_resolution_clock::now();
	auto distances = dijkstra_algorithm(g, s, p);
	auto endTime = chrono::high_resolution_clock::now();

	float t = chrono::duration_cast<std::chrono::microseconds>( endTime - startTime ).count();
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xb210
callq 0x4060
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rcx
movq %rax, -0x48(%rbp)
movq 0x34068(%rip), %rax     # 0x3e2f0
leaq -0x78(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq *%rax
jmp 0xa294
callq 0x4060
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb790
movq %rax, -0xc0(%rbp)
jmp 0xa2b9
movq -0xc0(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb760
movq %rax, -0xc8(%rbp)
jmp 0xa2dc
movq -0xc8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xb7e0
movq %rax, -0xd0(%rbp)
jmp 0xa2ff
movq -0xd0(%rbp), %rax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x94(%rbp)
movss -0x94(%rbp), %xmm0
movss %xmm0, -0xd4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb400
leaq -0x40(%rbp), %rdi
callq 0xb530
movss -0xd4(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xa36f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb400
leaq -0x40(%rbp), %rdi
callq 0xb530
movq -0x80(%rbp), %rdi
callq 0x4520
nopw %cs:(%rax,%rax)
// File: flastest[P]HeterogeneousParallelDijkstra/workloads.cc
// Function: test_DOTA(bool)
bool test_DOTA(bool TEST_DEBUG){
	//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah
	if (TEST_DEBUG) std::cout<<"loading graph from BBO"<<std::endl;
	graph_t g = graph_from_file("DotaLeague/DotaLeague_Edge_Basic",true);


	//number of nodes in g
	int num_nodes = num_vertices(g);

	std::vector<vertex_descriptor> p(num_nodes);

	//get a source node...
	vertex_descriptor s = vertex(1, g);

	std::vector<int> BGL_results = testBGL ( g,  s, p);


	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0xa3cb
movq 0x33c18(%rip), %rdi     # 0x3dfc8
leaq 0x1ecff(%rip), %rsi     # 0x290b6
callq 0x4310
movq %rax, %rdi
movq 0x33bd2(%rip), %rsi     # 0x3df98
callq 0x4370
leaq -0x61(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x4530
movq -0xf8(%rbp), %rdx
leaq 0x1ece4(%rip), %rsi     # 0x290cd
leaq -0x60(%rbp), %rdi
callq 0xb800
jmp 0xa3f4
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x26360
jmp 0xa408
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x61(%rbp), %rdi
callq 0x4390
leaq -0x40(%rbp), %rdi
callq 0xae10
movq %rax, -0x100(%rbp)
jmp 0xa42c
movq -0x100(%rbp), %rax
movl %eax, -0x78(%rbp)
movslq -0x78(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xb250
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xb270
jmp 0xa470
leaq -0x91(%rbp), %rdi
callq 0xb2e0
movl $0x1, %edi
leaq -0x40(%rbp), %rsi
callq 0xb230
movq %rax, -0x118(%rbp)
jmp 0xa493
movq -0x118(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xf0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb300
jmp 0xa4b3
movq -0xa0(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x90(%rbp), %rcx
callq 0x4cb0
jmp 0xa4d6
leaq -0xf0(%rbp), %rdi
callq 0xb380
leaq -0xb8(%rbp), %rdi
callq 0xb120
leaq -0x90(%rbp), %rdi
callq 0xb4d0
leaq -0x40(%rbp), %rdi
callq 0xb380
movb $0x1, %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa533
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x61(%rbp), %rdi
callq 0x4390
jmp 0xa5a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x91(%rbp), %rdi
callq 0xb2e0
jmp 0xa598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa58c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xb380
leaq -0x90(%rbp), %rdi
callq 0xb4d0
leaq -0x40(%rbp), %rdi
callq 0xb380
movq -0x70(%rbp), %rdi
callq 0x4520
nopw (%rax,%rax)
// File: flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: print_thread_debug(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::ostream&)
void print_thread_debug(int thread_id, std::string debug_message, ostream& output_stream)
{
	//first lock the mutex
	std::lock_guard<std::mutex> guard(print_mutex);
	//then print
	output_stream<< "thread: " << thread_id << ": " << debug_message <<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x2381a(%rip), %rsi     # 0x3e348
leaq -0x20(%rbp), %rdi
callq 0x1d9a0
movq -0x18(%rbp), %rdi
leaq 0xfd3e(%rip), %rsi      # 0x2a880
callq 0x4310
movq %rax, -0x38(%rbp)
jmp 0x1ab4d
movq -0x38(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x4510
movq %rax, -0x48(%rbp)
jmp 0x1ab5f
movq -0x48(%rbp), %rdi
leaq 0xfd1c(%rip), %rsi      # 0x2a886
callq 0x4310
movq %rax, -0x50(%rbp)
jmp 0x1ab75
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x42f0
movq %rax, -0x58(%rbp)
jmp 0x1ab88
movq -0x58(%rbp), %rdi
movq 0x23405(%rip), %rsi     # 0x3df98
callq 0x4370
jmp 0x1ab9a
leaq -0x20(%rbp), %rdi
callq 0x1d9d0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1d9d0
movq -0x28(%rbp), %rdi
callq 0x4520
nopw (%rax,%rax)
// File: flastest[P]HeterogeneousParallelDijkstra/BGL_Dijkstra.cc
// Function: initialize_distances_from_source(boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::no_property, boost::property<boost::edge_weight_t, int, boost::no_property>, boost::no_property, boost::listS> const&)
distance_map_t initialize_distances_from_source(
								const graph_t &graph)
{
	map<vertex_descriptor, float> distances;
	
	int num_nodes = num_vertices(graph);

	for (int i = 0; i < num_nodes; ++i)
	{
		distances[vertex(i,graph)] = INFINITY;
	}

	return distances;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1da00
movq -0x10(%rbp), %rdi
callq 0xae10
movq %rax, -0x38(%rbp)
jmp 0x1ac03
movq -0x38(%rbp), %rax
movl %eax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1ac79
movslq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb230
movq %rax, -0x50(%rbp)
jmp 0x1ac2c
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xad00
movq %rax, -0x58(%rbp)
jmp 0x1ac47
movq -0x58(%rbp), %rax
movss 0xfc19(%rip), %xmm0     # 0x2a86c
movss %xmm0, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1ac11
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb400
jmp 0x1ac96
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1ac8c
movq -0x48(%rbp), %rdi
callq 0xb400
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4520
nop
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/reset.cc
// Function: main
int main() 
{
	int j = 42;
	reset(j);  // j is passed by reference; the value in j is changed
	cout << "j = " << j  << endl;  // prints j = 0

	j = 42;    // restore the original value of j
	reset(&j);                     // changes j but not the address of j
	cout << "j = "  << j << endl;  // prints j = 0

	j = 42;    // restore the original value of j
	int *p = &j;
	reset(p); // changes object to which p points not the address in p
	cout << "j = "  << *p << endl;  // prints j = 0

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x11c0
movq 0x2db2(%rip), %rdi      # 0x3fd8
leaq 0xdd7(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d81(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x11e0
movq 0x2d75(%rip), %rdi      # 0x3fd8
leaq 0xd9a(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d44(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11e0
movq 0x2d30(%rip), %rdi      # 0x3fd8
leaq 0xd55(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2cfc(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: onlyuser[P]Sandbox/test_c/c++14/main.cpp
// Function: A::~A()
~A()
    {
        if(m_buf) {
            std::cout << "A::~A(\"" << m_buf << "\")" << std::endl;
            delete []m_buf;
            return;
        }
        std::cout << "A::~A()" << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x2afd
movq 0x7547(%rip), %rdi      # 0x9fd8
leaq 0x363a(%rip), %rsi      # 0x60d2
callq 0x20b0
movq %rax, -0x18(%rbp)
jmp 0x2aa3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x20b0
movq %rax, -0x20(%rbp)
jmp 0x2ab9
movq -0x20(%rbp), %rdi
leaq 0x360b(%rip), %rsi      # 0x60cf
callq 0x20b0
movq %rax, -0x28(%rbp)
jmp 0x2acf
movq -0x28(%rbp), %rdi
movq 0x74e6(%rip), %rsi      # 0x9fc0
callq 0x20e0
jmp 0x2ae1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2afb
movq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0x2b28
movq 0x74d4(%rip), %rdi      # 0x9fd8
leaq 0x35cf(%rip), %rsi      # 0x60da
callq 0x20b0
movq %rax, -0x38(%rbp)
jmp 0x2b16
movq -0x38(%rbp), %rdi
movq 0x749f(%rip), %rsi      # 0x9fc0
callq 0x20e0
jmp 0x2b28
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3070
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::SkipList(int)
SkipList::SkipList(int maxl) {
  max_level = maxl;
  if (max_level == 0) max_level = 1;
  if (max_level > MAX_LEVEL) max_level = MAX_LEVEL;
  head = new node();
  tail = new node();
  head->key = -1;
  head->topLevel = max_level;
  tail->key = INT_MAX;
  tail->topLevel = max_level;
  for (int i = 0; i < MAX_LEVEL; i++) {
	for (int k = 0; k < FANOUT; k++) {
	  head->nexts[i][k].nxt = tail;
	  head->nexts[i][k].prefix = INT_MAX;
	}
  }
  count = 0;
  pointer_follows = 0;
  for (int i = 0; i <= FANOUT; i++) {
	drop_down_pred[i] = 0;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x1280
movq 0x18(%rsp), %rax
movl $0x1, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpl $0xd, 0x10(%rax)
jle 0x1297
movq 0x18(%rsp), %rax
movl $0xd, 0x10(%rax)
movl $0x348, %edi            # imm = 0x348
callq 0x10c0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x348, %edx            # imm = 0x348
callq 0x1060
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x348, %edi            # imm = 0x348
callq 0x10c0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x348, %edx            # imm = 0x348
callq 0x1060
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
movl 0x10(%rax), %edx
movq (%rax), %rcx
movl %edx, 0x4(%rcx)
movq 0x8(%rax), %rcx
movl $0x7fffffff, (%rcx)     # imm = 0x7FFFFFFF
movl 0x10(%rax), %ecx
movq 0x8(%rax), %rax
movl %ecx, 0x4(%rax)
movl $0x0, 0x28(%rsp)
cmpl $0xd, 0x28(%rsp)
jge 0x13a2
movl $0x0, 0x24(%rsp)
cmpl $0x4, 0x24(%rsp)
jge 0x1390
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rax), %rcx
addq $0x8, %rcx
movslq 0x28(%rsp), %rsi
shlq $0x6, %rsi
addq %rsi, %rcx
movslq 0x24(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
addq $0x8, %rax
movslq 0x28(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x132b
jmp 0x1392
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x131c
movq 0x18(%rsp), %rax
movl $0x0, 0x2c(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x20(%rsp)
cmpl $0x4, 0x20(%rsp)
jg 0x13e3
movq 0x18(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl $0x0, 0x14(%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x13bd
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::~SkipList()
SkipList::~SkipList() {
  node* ptr = head;
  while (ptr != NULL && ptr != tail) {
	node* tmp = ptr;
	ptr = ptr->nexts[0][0].nxt;
	delete tmp;
  }
  if (head) delete head;
  if (tail) delete tail;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x38(%rsp)
movb %al, 0x27(%rsp)
je 0x142e
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
cmpq 0x8(%rcx), %rax
setne %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x1438
jmp 0x1471
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x146f
movq 0x18(%rsp), %rdi
movl $0x348, %esi            # imm = 0x348
callq 0x10d0
jmp 0x140b
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x14a0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x149e
movq 0x10(%rsp), %rdi
movl $0x348, %esi            # imm = 0x348
callq 0x10d0
jmp 0x14a0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14d1
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14cf
movq 0x8(%rsp), %rdi
movl $0x348, %esi            # imm = 0x348
callq 0x10d0
jmp 0x14d1
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::lookup(int)
int SkipList::lookup(int key) {
  node *preds[max_level][FANOUT], *succs[max_level][FANOUT];
  //if (findNode(key, preds, succs) >= 0) {
  if (fastFindNode(key) >= 0) {
	return 1;
  } else {
	return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl 0x10(%rdi), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl 0x10(%rdi), %eax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x1550
cmpl $0x0, %eax
jl 0x1525
movl $0x1, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x1533
movl $0x0, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::fastFindNode(int)
int SkipList::fastFindNode(int key) {
  node* pred = head;
  int lFound = -1;
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level][FANOUT-1].nxt;
	while (key > pred->nexts[level][FANOUT-1].prefix) {
	  pred = curr;
	  curr = pred->nexts[level][FANOUT-1].nxt;
	  inc();
	}
	int extra = 0;
	while (key > pred->nexts[level][extra].prefix) extra++;
	if (lFound == -1 && key == pred->nexts[level][extra].prefix) {
	  return level;
	}
	curr = pred->nexts[level][extra].nxt;
	if (extra > 0) {
	  pred = pred->nexts[level][extra-1].nxt;
	  inc();
	}
  }
  return -1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
jl 0x16f8
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x30(%rcx), %eax
jle 0x1601
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x4150
jmp 0x15af
movl $0x0, 0x14(%rsp)
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jle 0x163f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1609
cmpl $-0x1, 0x24(%rsp)
jne 0x167c
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x167c
movl 0x20(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x1700
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x16e6
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x4150
jmp 0x16e8
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1586
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::init_list(int, int, int)
SkipList* SkipList::init_list(int sz, int high, int max_level) {
  SkipList* skip = new SkipList(max_level);
  int count = 0;
  while (count < sz) {
	if (skip->insert(rand() % high) > 0) {
	  count++;
	}
  }
  return skip;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl $0x30, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %esi
callq 0x1250
jmp 0x2310
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x237d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x1050
movq (%rsp), %rdi
cltd
idivl 0x30(%rsp)
movl %edx, %esi
callq 0x1fa0
cmpl $0x0, %eax
jle 0x237b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x237b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x30, %esi
callq 0x10d0
jmp 0x2387
jmp 0x2322
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: SkipList::detailed_print()
void SkipList::detailed_print() {
  node* ptr = head;
  while (ptr != tail) {
	printf("[K:%02d ", ptr->key);
	for (int level = 0; level < ptr->topLevel; level++) {
	  printf("N: ");
	  for (int k = 0; k < FANOUT; k++) {
		if (ptr->nexts[level][k].prefix == INT_MAX) {
		  printf("ND ");
		} else {		
		  printf("%02d ", ptr->nexts[level][k].nxt->key);
		}
	  }
	}
	printf("]\n");
	ptr = ptr->nexts[0][0].nxt;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
je 0x2e52
movq 0x18(%rsp), %rax
movl (%rax), %esi
leaq 0x22b3(%rip), %rdi      # 0x5010
movb $0x0, %al
callq 0x1040
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2e31
leaq 0x2294(%rip), %rdi      # 0x5019
movb $0x0, %al
callq 0x1040
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x2e1f
movq 0x18(%rsp), %rax
addq $0x8, %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
jne 0x2dd8
leaq 0x224e(%rip), %rdi      # 0x501d
movb $0x0, %al
callq 0x1040
jmp 0x2e0d
movq 0x18(%rsp), %rax
addq $0x8, %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
leaq 0x220d(%rip), %rdi      # 0x5013
movb $0x0, %al
callq 0x1040
jmp 0x2e0f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2d94
jmp 0x2e21
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2d6c
leaq 0x21e9(%rip), %rdi      # 0x5021
movb $0x0, %al
callq 0x1040
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2d3b
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: fillRandom(SkipList*, int)
void fillRandom(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	int rnd = rand() % sz;
	if (skip->insert(rnd) > 0) {
	  printf("%d ", rnd);
	  count++;
	}
  }
  skip->pretty_print();
  //  skip->detailed_print();
  printf("\nInserted %d keys randomly\n", count);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x31bf
callq 0x1050
cltd
idivl 0xc(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x1fa0
cmpl $0x0, %eax
jle 0x31bd
movl 0x4(%rsp), %esi
leaq 0x1eda(%rip), %rdi      # 0x5085
movb $0x0, %al
callq 0x1040
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3175
movq 0x10(%rsp), %rdi
callq 0x2e60
movl 0x8(%rsp), %esi
leaq 0x1eb5(%rip), %rdi      # 0x5089
movb $0x0, %al
callq 0x1040
addq $0x18, %rsp
retq
// File: narula[P]skiplists/skiplist-extra.cc
// Function: fillForward(SkipList*, int)
void fillForward(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	if (skip->insert(count) > 0) {
	  count++;
	}
  }
  printf("Inserted %d keys forwards\n", count);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x321f
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x1fa0
cmpl $0x0, %eax
jle 0x321d
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x31f5
movl 0x8(%rsp), %esi
leaq 0x1e7b(%rip), %rdi      # 0x50a5
movb $0x0, %al
callq 0x1040
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: fillBackward(SkipList*, int)
void fillBackward(SkipList* skip, int sz) {
  int count = 0;
  while (count < sz) {
	if (skip->insert(sz-count-1) > 0) {
	  count++;
	}
  }
  printf("Inserted %d keys backwards\n", count);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x3286
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
subl 0x8(%rsp), %esi
subl $0x1, %esi
callq 0x1fa0
cmpl $0x0, %eax
jle 0x3284
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3255
movl 0x8(%rsp), %esi
leaq 0x1e2f(%rip), %rdi      # 0x50c0
movb $0x0, %al
callq 0x1040
addq $0x18, %rsp
retq
nopl (%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: empty_fill(int, void (*)(SkipList*, int))
SkipList* empty_fill(int sz, void (*fill)(SkipList*, int)) {
  int maxl = floor(log(sz)/log(FANOUT)) + 1;
  SkipList* skip = new SkipList(maxl);
  fill(skip, sz);
  return skip;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl 0x44(%rsp), %edi
callq 0x41a0
movsd %xmm0, 0x8(%rsp)
movl $0x4, %edi
callq 0x41a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x1100
movsd 0x1d28(%rip), %xmm1     # 0x5008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x34(%rsp)
movl $0x30, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %esi
callq 0x1250
jmp 0x330c
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x44(%rsp), %esi
callq *%rax
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x30, %esi
callq 0x10d0
movq 0x20(%rsp), %rdi
callq 0x1120
nopw (%rax,%rax)
// File: narula[P]skiplists/skiplist-extra.cc
// Function: perfect_test(int)
int perfect_test(int sz) {
  printf("Testing perfect skiplist lookups... ");
  int maxl = floor(log(sz)/log(FANOUT)) + 1;
  SkipList* sk = perfect_list(sz, maxl);
  for (int i = 0; i < sz; i++) {
	assert (sk->lookup(i) > 0);
  }
  assert (sk->lookup(99) <= 0);
  printf("PASSED\n");
  printf("Testing perfect skiplist inserts... ");
  perfect_insert_test(sk);
  printf("PASSED\n");
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
leaq 0x1891(%rip), %rdi      # 0x53b0
movb $0x0, %al
callq 0x1040
movl 0x24(%rsp), %edi
callq 0x41a0
movsd %xmm0, 0x8(%rsp)
movl $0x4, %edi
callq 0x41a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x1100
movsd 0x14af(%rip), %xmm1     # 0x5008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x23a0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x3bcc
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14e0
cmpl $0x0, %eax
jle 0x3b9e
jmp 0x3bbd
leaq 0x1830(%rip), %rdi      # 0x53d5
leaq 0x1544(%rip), %rsi      # 0x50f0
movl $0x221, %edx            # imm = 0x221
leaq 0x182f(%rip), %rcx      # 0x53e7
callq 0x1070
jmp 0x3bbf
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3b7f
movq 0x18(%rsp), %rdi
movl $0x63, %esi
callq 0x14e0
cmpl $0x0, %eax
jg 0x3be2
jmp 0x3c01
leaq 0x14f3(%rip), %rdi      # 0x50dc
leaq 0x1500(%rip), %rsi      # 0x50f0
movl $0x223, %edx            # imm = 0x223
leaq 0x17eb(%rip), %rcx      # 0x53e7
callq 0x1070
leaq 0x17a0(%rip), %rdi      # 0x53a8
movb $0x0, %al
callq 0x1040
leaq 0x17e7(%rip), %rdi      # 0x53fd
movb $0x0, %al
callq 0x1040
movq 0x18(%rsp), %rdi
callq 0x3360
leaq 0x177a(%rip), %rdi      # 0x53a8
movb $0x0, %al
callq 0x1040
ud2
nopw (%rax,%rax)
// File: ChnMasterOG[P]KmerGO2/kmergo/KmerGO_io.h
// Function: joinPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string joinPath(std::string path1, std::string path2)
{
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
	/* replace / to \ */
	while (1)
	{
		std::string::size_type position;
		position = path1.find("/");
		if (position == path1.npos) break;
		path1 = path1.replace(position, 1, "\\");
	}
	while (1)
	{
		std::string::size_type position;
		position = path2.find("/");
		if (position == path2.npos) break;
		path2 = path2.replace(position, 1, "\\");
	}
	/* join two paths */
	std::string::iterator it = path1.end();
	--it;
	if (*it != '\\') path1.insert(path1.end(), '\\');
#elif defined(__linux__) || defined(linux)
	/* replace \ to / */
	while (1)
	{
		std::string::size_type position;
		position = path1.find("\\");
		if (position == path1.npos) break;
		path1 = path1.replace(position, 1, "/");
	}
	while (1)
	{
		std::string::size_type position;
		position = path2.find("\\");
		if (position == path2.npos) break;
		path2 = path2.replace(position, 1, "/");
	}
	/* join two paths */
	std::string::iterator it = path1.end();
	--it;
	if (*it != '/') path1.insert(path1.end(), '/');
#endif
	path1.insert(path1.size(), path2);
	return path1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x60(%rbp), %rdi
leaq 0x1aec7f(%rip), %rsi    # 0x5b6121
xorl %eax, %eax
movl %eax, %edx
callq 0x4a0b30
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x4074b8
jmp 0x4074df
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
leaq 0x1b8730(%rip), %rcx    # 0x5bfbfc
callq 0x4a0190
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x49f000
jmp 0x407497
jmp 0x4074e1
movq -0x68(%rbp), %rdi
leaq 0x1aec35(%rip), %rsi    # 0x5b6121
xorl %eax, %eax
movl %eax, %edx
callq 0x4a0b30
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x407502
jmp 0x407529
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
leaq 0x1b86e6(%rip), %rcx    # 0x5bfbfc
callq 0x4a0190
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x49f000
jmp 0x4074e1
movq -0x60(%rbp), %rdi
callq 0x49f120
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x408420
leaq -0x30(%rbp), %rdi
callq 0x408440
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x407580
movq -0x60(%rbp), %rdi
callq 0x49f120
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x408460
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x2f, %edx
callq 0x49fab0
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
callq 0x49f1f0
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x4a00a0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x49ef20
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: ChnMasterOG[P]KmerGO2/kmergo/kmer_union.cpp
// Function: num2ACGT(unsigned char)
char num2ACGT(unsigned char num)
{
	if (num == 0) return 'A';
	else if (num == 1) return 'C';
	else if (num == 2) return 'G';
	else return 'T';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x40a2f9
movb $0x41, -0x1(%rbp)
jmp 0x40a31b
movzbl -0x2(%rbp), %eax
cmpl $0x1, %eax
jne 0x40a308
movb $0x43, -0x1(%rbp)
jmp 0x40a31b
movzbl -0x2(%rbp), %eax
cmpl $0x2, %eax
jne 0x40a317
movb $0x47, -0x1(%rbp)
jmp 0x40a31b
movb $0x54, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq