LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::PrintFailedTests(testing::UnitTest const&)
void PrintFailedTests(const UnitTest& unit_test) {
        const int failed_test_count = unit_test.failed_test_count();
        if (failed_test_count == 0) {
            return;
        }
        PRINT_SEPARATOR;
        printf("Failed tests: \n");
        for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
            const TestCase& test_case = *unit_test.GetTestCase(i);
            if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
                continue;
            }

            for (int j = 0; j < test_case.total_test_count(); ++j) {
                const TestInfo& test_info = *test_case.GetTestInfo(j);
                if (!test_info.should_run() || test_info.result()->Passed()) {
                    continue;
                }
                PRINT_EXTENDER;
                printf("%s.%s", test_case.name(), test_info.name());
                PrintFullTestCommentIfPresent(test_info);
                printf("\n");
            }   
        }
        PRINT_SEPARATOR;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77d90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xa4bef
jmp 0xa4d3b
leaq 0x736a(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
leaq 0x7521(%rip), %rdi      # 0xac125
movb $0x0, %al
callq 0xd090
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77dc0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0xa4d2d
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x77df0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x83ac0
testb $0x1, %al
jne 0xa4c4d
jmp 0xa4c5b
movq -0x20(%rbp), %rdi
callq 0x6ec20
cmpl $0x0, %eax
jne 0xa4c60
jmp 0xa4d1f
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6ede0
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0xa4d1d
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x763f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x83ae0
testb $0x1, %al
jne 0xa4ca2
jmp 0xa4cb9
movq -0x30(%rbp), %rdi
callq 0x839c0
movq %rax, %rdi
callq 0x839e0
testb $0x1, %al
jne 0xa4cb9
jmp 0xa4cbb
jmp 0xa4d0f
leaq 0x72f3(%rip), %rdi      # 0xabfb5
movb $0x0, %al
callq 0xd090
movq -0x20(%rbp), %rdi
callq 0x83920
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x825f0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0x546d(%rip), %rdi      # 0xaa15a
movb $0x0, %al
callq 0xd090
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa4b10
leaq 0x542d(%rip), %rdi      # 0xaa135
movb $0x0, %al
callq 0xd090
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa4c67
jmp 0xa4d1f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa4c12
leaq 0x722c(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
addq $0x50, %rsp
popq %rbp
retq
// File: mehrangoli[P]Static-Data-Extractor/main.cpp
// Function: main
int main()
{
	string DebugSymbolPath;
    cout << "Please enter the Debug Symbol path: ";
    cin >> DebugSymbolPath;
	
	ifstream InputFile(DebugSymbolPath.c_str());
	ScMain scmain;
	
	bool flag = scmain.find_scmain(InputFile);
	if (flag){
		cout << "\033[1;32mStarting XML file generation...\033[0m\n";
		scmain.print_data_XML ();
		cout <<"\033[1;32mXML file is successfully generated!\033[0m\n";
		scmain.print_data ();
	}
	else
		cout <<"\033[1;31mUnable to generate XML file!\033[0m\n";
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3340
movq 0x1902e(%rip), %rdi     # 0x1efd0
leaq 0x110dc(%rip), %rsi     # 0x17085
callq 0x3240
jmp 0x5fb0
movq 0x19029(%rip), %rdi     # 0x1efe0
leaq -0x28(%rbp), %rsi
callq 0x3300
jmp 0x5fc2
leaq -0x28(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
movl $0x8, %edx
callq 0x3450
jmp 0x5fe1
leaq -0x258(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x62d0
movq -0x268(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0xba20
movb %al, -0x25a(%rbp)
jmp 0x600f
movb -0x25a(%rbp), %al
andb $0x1, %al
movb %al, -0x259(%rbp)
testb $0x1, -0x259(%rbp)
je 0x60a2
movq 0x18fa3(%rip), %rdi     # 0x1efd0
leaq 0x11076(%rip), %rsi     # 0x170aa
callq 0x3240
jmp 0x603b
leaq -0x258(%rbp), %rdi
callq 0x7cd0
jmp 0x6049
movq 0x18f80(%rip), %rdi     # 0x1efd0
leaq 0x1107f(%rip), %rsi     # 0x170d6
callq 0x3240
jmp 0x605e
leaq -0x258(%rbp), %rdi
callq 0x7980
jmp 0x606c
jmp 0x60b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x60ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x62f0
leaq -0x240(%rbp), %rdi
callq 0x30a0
jmp 0x60ed
movq 0x18f27(%rip), %rdi     # 0x1efd0
leaq 0x11056(%rip), %rsi     # 0x17106
callq 0x3240
jmp 0x60b7
jmp 0x60b9
movl $0x0, -0x4(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x62f0
leaq -0x240(%rbp), %rdi
callq 0x30a0
leaq -0x28(%rbp), %rdi
callq 0x3190
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x3190
movq -0x30(%rbp), %rdi
callq 0x3420
nop
// File: mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::find_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ScMain::find_element (string str){
	for (int i=0; i< static_data_final.size(); ++i){
		if (static_data_final[i].get_name() == str)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0xe490
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x8290
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xde90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x13600
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xe4c0
movb %al, -0x59(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x827b
jmp 0x8283
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8297
jmp 0x8285
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8223
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::set_static_data_func(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void ScMain::set_static_data_func (string m_name, NT f_name){
	Component temp_struct;
	int index = find_element(m_name);
	
	if (index != -1){
		static_data_final[index].set_func(f_name);
	}
	else{
		temp_struct.set_name (m_name);
		temp_struct.set_func(f_name);
		static_data_final.push_back(temp_struct);		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rsi, -0x168(%rbp)
movq %rdx, -0x178(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xe3e0
movq -0x168(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3120
jmp 0xa6f1
movq -0x170(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x8200
movl %eax, -0x17c(%rbp)
jmp 0xa70c
leaq -0xb0(%rbp), %rdi
callq 0x3190
movl -0x17c(%rbp), %eax
movl %eax, -0x8c(%rbp)
cmpl $-0x1, -0x8c(%rbp)
je 0xa7e3
movq -0x170(%rbp), %rdi
movslq -0x8c(%rbp), %rsi
callq 0xde90
movq -0x178(%rbp), %rsi
movq %rax, -0x188(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xe340
jmp 0xa760
movq -0x188(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x13370
jmp 0xa775
leaq -0x100(%rbp), %rdi
callq 0x6740
jmp 0xa8a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xa8bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3190
jmp 0xa8bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x6740
jmp 0xa8bb
movq -0x168(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x3120
jmp 0xa7f8
leaq -0x88(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x135d0
jmp 0xa80d
leaq -0x120(%rbp), %rdi
callq 0x3190
movq -0x178(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0xe340
jmp 0xa82e
leaq -0x88(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x13370
jmp 0xa843
leaq -0x160(%rbp), %rdi
callq 0x6740
movq -0x170(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xe420
jmp 0xa864
jmp 0xa8a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x3190
jmp 0xa8bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x6740
jmp 0xa8bb
leaq -0x88(%rbp), %rdi
callq 0x6570
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x6570
movq -0xb8(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::set_static_data_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void ScMain::set_static_data_var (string m_name, NT v_name){
	Component temp_struct;
	int index = find_element(m_name);
	
	if (index != -1){
		static_data_final[index].set_var(v_name);	
	}
	else{
		temp_struct.set_name (m_name);
		temp_struct.set_var(v_name);
		static_data_final.push_back(temp_struct);		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rsi, -0x168(%rbp)
movq %rdx, -0x178(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xe3e0
movq -0x168(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3120
jmp 0xa931
movq -0x170(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x8200
movl %eax, -0x17c(%rbp)
jmp 0xa94c
leaq -0xb0(%rbp), %rdi
callq 0x3190
movl -0x17c(%rbp), %eax
movl %eax, -0x8c(%rbp)
cmpl $-0x1, -0x8c(%rbp)
je 0xaa23
movq -0x170(%rbp), %rdi
movslq -0x8c(%rbp), %rsi
callq 0xde90
movq -0x178(%rbp), %rsi
movq %rax, -0x188(%rbp)
leaq -0x100(%rbp), %rdi
callq 0xe340
jmp 0xa9a0
movq -0x188(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x13510
jmp 0xa9b5
leaq -0x100(%rbp), %rdi
callq 0x6740
jmp 0xaae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xaafb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3190
jmp 0xaafb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x6740
jmp 0xaafb
movq -0x168(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x3120
jmp 0xaa38
leaq -0x88(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x135d0
jmp 0xaa4d
leaq -0x120(%rbp), %rdi
callq 0x3190
movq -0x178(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0xe340
jmp 0xaa6e
leaq -0x88(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x13510
jmp 0xaa83
leaq -0x160(%rbp), %rdi
callq 0x6740
movq -0x170(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xe420
jmp 0xaaa4
jmp 0xaae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x3190
jmp 0xaafb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x6740
jmp 0xaafb
leaq -0x88(%rbp), %rdi
callq 0x6570
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x6570
movq -0xb8(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: string_finder(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool string_finder (string str1, string str2){
	size_t found = str1.find(str2);
	
	if (found!=string::npos)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x34b0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x10e3a
movb $0x1, -0x1(%rbp)
jmp 0x10e3e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: GotoLine(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
void GotoLine(ifstream& file, unsigned int num){
	file.clear();
    file.seekg(0, ios::beg);
	
    for(int i=0; i < num; ++i){
        file.ignore(numeric_limits<streamsize>::max(),'\n');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x33f0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3330
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x10eb8
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x11e80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0xa, %edx
callq 0x31a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10e87
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string &s, char delim) {
    vector<string> elems;
	string buff;                 //-----buffer string
    stringstream ss(s);       //-----insert the string into a stream
	
	while (getline(ss, buff, delim))
		elems.push_back(buff);
	return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0xdfc0
leaq -0x38(%rbp), %rdi
callq 0x3340
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x11e90
movl %eax, -0x1d0(%rbp)
jmp 0x10f1d
movl -0x1d0(%rbp), %edx
movq -0x1d8(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x33b0
jmp 0x10f38
jmp 0x10f3a
movsbl -0x11(%rbp), %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3460
movq %rax, -0x1f0(%rbp)
jmp 0x10f57
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32f0
movb %al, -0x1f1(%rbp)
jmp 0x10f75
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x10f81
jmp 0x10fc9
movq -0x1e8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11eb0
jmp 0x10f93
jmp 0x10f3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x10fea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31e0
jmp 0x10fea
movb $0x1, -0x12(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31e0
leaq -0x38(%rbp), %rdi
callq 0x3190
testb $0x1, -0x12(%rbp)
jne 0x1100d
jmp 0x11001
leaq -0x38(%rbp), %rdi
callq 0x3190
movq -0x1e8(%rbp), %rdi
callq 0x6270
jmp 0x1101d
movq -0x1e8(%rbp), %rdi
callq 0x6270
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: replace_first_occurrence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string replace_first_occurrence (string& s, const string& toReplace, const string& replaceWith){
    size_t pos = s.find(toReplace);
	
    if (pos == string::npos)
		return s;
    return s.replace(pos, toReplace.length(), replaceWith);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x34b0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x1107e
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
jmp 0x110b7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3380
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x30e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3120
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: findchar_exact(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
bool findchar_exact (string in1 , vector<string> chars){
	for (auto i: chars)
		if (in1 == i)
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11f20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11f50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11f80
testb $0x1, %al
jne 0x11115
jmp 0x11172
leaq -0x28(%rbp), %rdi
callq 0x11fc0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x3120
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xe4c0
testb $0x1, %al
jne 0x1113d
jmp 0x1114a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x11151
movl $0x0, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3190
movl -0x54(%rbp), %eax
testl %eax, %eax
je 0x11165
jmp 0x11163
jmp 0x11176
jmp 0x11167
leaq -0x28(%rbp), %rdi
callq 0x11fe0
jmp 0x11102
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: find_in_vector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int find_in_vector(vector<string> vect, string str){
	for (unsigned i=0; i<vect.size(); ++i){
		if (string_finder(vect[i], str))
			return i;
	}	
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x88(%rbp)
callq 0xe320
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x11331
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xe270
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3120
jmp 0x112d1
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x10e10
movb %al, -0x89(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3190
leaq -0x40(%rbp), %rdi
callq 0x3190
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x11302
jmp 0x11321
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11338
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
jmp 0x11344
jmp 0x11323
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11282
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: remove_element_vector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void remove_element_vector(vector<string>& vect, string str){
	auto itt = vect.begin();
	
	while (itt!=vect.end()){
		if (*itt==str)
			vect.erase (itt);
		else
			++itt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11f20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11f50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11f80
testb $0x1, %al
jne 0x11391
jmp 0x113df
leaq -0x18(%rbp), %rdi
callq 0x11fc0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0xe4c0
testb $0x1, %al
jne 0x113ac
jmp 0x113d4
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12070
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12000
movq %rax, -0x30(%rbp)
jmp 0x113dd
leaq -0x18(%rbp), %rdi
callq 0x11fe0
jmp 0x11371
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: set_NT_vector(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void set_NT_vector (vector<NT>& vect, NT Var){
	for (int i=0; i< vect.size(); ++i){
		if ((vect[i].first == Var.first) && (vect[i].second == Var.second))
			return;
	}
	vect.push_back(Var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf540
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1147d
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x120b0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0xe4c0
testb $0x1, %al
jne 0x11447
jmp 0x11470
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x120b0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
addq $0x20, %rsi
callq 0xe4c0
testb $0x1, %al
jne 0x1146e
jmp 0x11470
jmp 0x1148a
jmp 0x11472
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1140b
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x120d0
addq $0x30, %rsp
popq %rbp
retq
// File: mehrangoli[P]Static-Data-Extractor/Component.cpp
// Function: Component::set_func(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void Component::set_func (NT Func){
	if (!Func.first.empty()){
		string TypeName = Func.first+"+"+Func.second;
		if (func_st.count(TypeName) == 0) {
			vector<NT> temp;
			func_st[TypeName] = temp;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, %rax
movq -0x90(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x33e0
testb $0x1, %al
jne 0x134a5
movq -0x88(%rbp), %rsi
leaq 0x4170(%rip), %rdx      # 0x1752e
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xe550
movq -0x88(%rbp), %rdx
movq -0x98(%rbp), %rsi
addq $0x20, %rdx
leaq -0x30(%rbp), %rdi
callq 0xe180
jmp 0x133eb
leaq -0x50(%rbp), %rdi
callq 0x3190
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146a0
movq %rax, -0xa0(%rbp)
jmp 0x1340a
movq -0xa0(%rbp), %rax
cmpq $0x0, %rax
jne 0x1348f
leaq -0x78(%rbp), %rdi
callq 0xdfe0
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146d0
movq %rax, -0xa8(%rbp)
jmp 0x13436
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x14700
jmp 0x13448
leaq -0x78(%rbp), %rdi
callq 0x65b0
jmp 0x1348f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3190
jmp 0x134ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1349a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x65b0
jmp 0x1349a
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x134a5
leaq -0x30(%rbp), %rdi
callq 0x3190
jmp 0x134ae
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Component.cpp
// Function: Component::set_var(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void Component::set_var (NT Var){
	for (int i=0; i< var_st.size(); ++i){
		if ((var_st[i].first == Var.first) && (var_st[i].second == Var.second))
			return;
	}
	var_st.push_back(Var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
callq 0xf540
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x135b1
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x120b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0xe4c0
testb $0x1, %al
jne 0x13577
jmp 0x135a4
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x120b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
addq $0x20, %rsi
callq 0xe4c0
testb $0x1, %al
jne 0x135a2
jmp 0x135a4
jmp 0x135c2
jmp 0x135a6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13533
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x120d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mehrangoli[P]Static-Data-Extractor/Component.cpp
// Function: Component::get_name_XML[abi:cxx11]()
string Component::get_name_XML (){
	string temp;
	if (name == "sc_main")
		temp = "<Global_function name = \"" + name + "\">";
	else
		temp = "<Module name = \"" + name + "\">";
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3340
movq -0xb8(%rbp), %rdi
addq $0x50, %rdi
leaq 0x3c95(%rip), %rsi      # 0x1730f
callq 0xde60
movb %al, -0xa9(%rbp)
jmp 0x13687
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x13696
jmp 0x1371b
movq -0xb8(%rbp), %rdx
addq $0x50, %rdx
leaq 0x3e88(%rip), %rsi      # 0x17530
leaq -0x68(%rbp), %rdi
callq 0x14950
jmp 0x136b3
leaq 0x3e90(%rip), %rdx      # 0x1754a
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xe1d0
jmp 0x136c9
movq -0xc8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x32d0
leaq -0x48(%rbp), %rdi
callq 0x3190
leaq -0x68(%rbp), %rdi
callq 0x3190
jmp 0x1379e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x137c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3190
jmp 0x137c4
movq -0xb8(%rbp), %rdx
addq $0x50, %rdx
leaq 0x3e20(%rip), %rsi      # 0x1754d
leaq -0xa8(%rbp), %rdi
callq 0x14950
jmp 0x1373b
leaq 0x3e08(%rip), %rdx      # 0x1754a
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xe1d0
jmp 0x13757
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x32d0
leaq -0x88(%rbp), %rdi
callq 0x3190
leaq -0xa8(%rbp), %rdi
callq 0x3190
jmp 0x1379e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3190
jmp 0x137c4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x137b4
movq -0xc8(%rbp), %rdi
callq 0x3190
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x3190
movq -0x20(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: mehrangoli[P]Static-Data-Extractor/Component.cpp
// Function: Component::get_var_XML[abi:cxx11]()
string Component::get_var_XML (){
	string temp;
	for (auto i: var_st){
		if (!i.first.empty()){
			temp = temp +"\t<Global_variable name = \""+i.first+"\"\ttype = \""+i.second+"\"></Global_variable>\n";
		}
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3340
movq -0x128(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12140
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12170
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x121a0
testb $0x1, %al
jne 0x13b77
jmp 0x13d22
leaq -0x28(%rbp), %rdi
callq 0x121e0
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0xe340
jmp 0x13b8e
leaq -0x70(%rbp), %rdi
callq 0x33e0
testb $0x1, %al
jne 0x13d00
movq -0x138(%rbp), %rsi
leaq 0x39bf(%rip), %rdx      # 0x1756c
leaq -0x120(%rbp), %rdi
callq 0xe550
jmp 0x13bbb
leaq -0x100(%rbp), %rdi
leaq -0x120(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xe180
jmp 0x13bd4
leaq 0x3933(%rip), %rdx      # 0x1750e
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0xe1d0
jmp 0x13bf0
leaq -0x50(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xe180
jmp 0x13c09
leaq 0x3977(%rip), %rdx      # 0x17587
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xe1d0
jmp 0x13c25
movq -0x138(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32d0
leaq -0xa0(%rbp), %rdi
callq 0x3190
leaq -0xc0(%rbp), %rdi
callq 0x3190
leaq -0xe0(%rbp), %rdi
callq 0x3190
leaq -0x100(%rbp), %rdi
callq 0x3190
leaq -0x120(%rbp), %rdi
callq 0x3190
jmp 0x13d00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13d17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13cf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13ce6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13cda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3190
leaq -0xe0(%rbp), %rdi
callq 0x3190
leaq -0x100(%rbp), %rdi
callq 0x3190
leaq -0x120(%rbp), %rdi
callq 0x3190
jmp 0x13d17
leaq -0x70(%rbp), %rdi
callq 0x6740
leaq -0x28(%rbp), %rdi
callq 0x12200
jmp 0x13b61
leaq -0x70(%rbp), %rdi
callq 0x6740
jmp 0x13d48
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x13d38
movq -0x138(%rbp), %rdi
callq 0x3190
movq -0x130(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x3190
movq -0x78(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/lsm-emulation.cpp
// Function: loadfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, int*)
void loadfile( string filename, vector<string>* table, int* num )
{
	ifstream infile;
	infile.open( filename );

	if( infile.fail() ){
		cout << "Error opening " << filename << endl;
	}

	while( infile.peek() != EOF ){
		string line;
		getline(infile,line);
		int pos1 = line.find(" ");
		int pos2 = line.find(" ", pos1+2);
	    string data = line.substr(pos1+1, pos2-pos1-1);
		//cout << data << " " << data.size() << endl;
		table->push_back( data );
		(*num)++;
	}

	infile.close();
	return;
}

// Assembly:
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rdi, 0x48(%rsp)
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq %rdx, 0x2b0(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x65a0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl $0x8, %edx
callq 0x6470
jmp 0x77cc
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0xa8(%rsp,%rax), %rdi
callq 0x6030
movb %al, 0x3f(%rsp)
jmp 0x77eb
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x77f5
jmp 0x7853
movq 0x787c4(%rip), %rdi     # 0x7ffc0
leaq 0x5c837(%rip), %rsi     # 0x6403a
callq 0x6500
movq %rax, 0x30(%rsp)
jmp 0x780f
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x6490
movq %rax, 0x28(%rsp)
jmp 0x7825
movq 0x28(%rsp), %rdi
movq 0x78777(%rip), %rsi     # 0x7ffa8
callq 0x6540
jmp 0x7838
jmp 0x7853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x799f
jmp 0x7855
leaq 0xa8(%rsp), %rdi
callq 0x6220
movl %eax, 0x24(%rsp)
jmp 0x7868
movl 0x24(%rsp), %eax
cmpl $-0x1, %eax
je 0x797b
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6700
movq 0x18(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x6110
jmp 0x7898
leaq 0x5d5b9(%rip), %rsi     # 0x64e58
movq %rsi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edx
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6930
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdx
callq 0x6930
movq 0x10(%rsp), %rsi
movl %eax, 0x70(%rsp)
movl 0x74(%rsp), %eax
movl %eax, %ecx
incl %ecx
movslq %ecx, %rdx
movl 0x70(%rsp), %ecx
notl %eax
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x50(%rsp), %rdi
callq 0x6530
jmp 0x78ff
movq 0x2b8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8140
jmp 0x7913
movq 0x2b0(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x6340
leaq 0x78(%rsp), %rdi
callq 0x6340
jmp 0x7855
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x796f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6340
leaq 0x78(%rsp), %rdi
callq 0x6340
jmp 0x799f
leaq 0xa8(%rsp), %rdi
callq 0x6140
jmp 0x798a
leaq 0xa8(%rsp), %rdi
callq 0x6180
addq $0x2c8, %rsp            # imm = 0x2C8
retq
leaq 0xa8(%rsp), %rdi
callq 0x6180
movq 0xa0(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::ReserveSpace(int, unsigned int*, unsigned int*)
char* LegacyBF::ReserveSpace(const int num_entry,
                                           uint32_t* total_bits,
                                           uint32_t* num_lines) {
  uint32_t sz = CalculateSpace(num_entry, total_bits, num_lines);
  char* data = new char[sz];
  memset(data, 0, sz);
  return data;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xab80
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %edi
callq 0x6040
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x62e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::GetTotalBitsForLocality(unsigned int)
uint32_t LegacyBF::GetTotalBitsForLocality(uint32_t total_bits) {
  uint32_t num_lines =
      (total_bits + CACHE_LINE_SIZE * 8 - 1) / (CACHE_LINE_SIZE * 8);

  // Make num_lines an odd number to make sure more bits are involved
  // when determining which block.
  if (num_lines % 2 == 0) {
    num_lines++;
  }
  return num_lines * (CACHE_LINE_SIZE * 8);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0x200, %eax            # imm = 0x200
subl $0x1, %eax
shrl $0x9, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xab73
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shll $0x9, %eax
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::CalculateSpace(int, unsigned int*, unsigned int*)
uint32_t LegacyBF::CalculateSpace(const int num_entry,
                                                uint32_t* total_bits,
                                                uint32_t* num_lines) {
  assert(bits_per_key_);
  if (num_entry != 0) {
    uint32_t total_bits_tmp = static_cast<uint32_t>(num_entry * bits_per_key_);

    *total_bits = GetTotalBitsForLocality(total_bits_tmp);
    *num_lines = *total_bits / (CACHE_LINE_SIZE * 8);
    num_lines_ = *num_lines;
    assert(*total_bits > 0 && *total_bits % 8 == 0);
  } else {
    // filter is empty, just leave space for metadata
    *total_bits = 0;
    *num_lines = 0;
  }

  // Reserve space for Filter
  uint32_t sz = *total_bits / 8;
  sz += 5;  // 4 bytes for num_lines, 1 byte for num_probes
  return sz;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rax)
je 0xaba8
jmp 0xabc7
leaq 0x5969a(%rip), %rdi     # 0x64249
leaq 0x59593(%rip), %rsi     # 0x64149
movl $0x92, %edx
leaq 0x59695(%rip), %rcx     # 0x64257
callq 0x6360
cmpl $0x0, 0x2c(%rsp)
je 0xac65
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
imull (%rdi), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
callq 0xab40
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movl %edx, (%rcx)
movq 0x20(%rsp), %rcx
movl (%rcx), %edx
shrl $0x9, %edx
movq 0x18(%rsp), %rcx
movl %edx, (%rcx)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, 0x7(%rsp)
jbe 0xac38
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xac42
jmp 0xac44
jmp 0xac63
leaq 0x59651(%rip), %rdi     # 0x6429c
leaq 0x594f7(%rip), %rsi     # 0x64149
movl $0x99, %edx
leaq 0x595f9(%rip), %rcx     # 0x64257
callq 0x6360
jmp 0xac7b
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %eax
shrl $0x3, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addl $0x5, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::CalculateNumEntry(unsigned int)
int LegacyBF::CalculateNumEntry(const uint32_t bytes) {
  assert(bits_per_key_);
  assert(bytes > 0);
  int high = static_cast<int>(bytes * 8 / bits_per_key_ + 1);
  int low = 1;
  int n = high;
  for (; n >= low; n--) {
    if (CalculateSpace(n) <= bytes) {
      break;
    }
  }
  assert(n < high);  // High should be an overestimation
  return n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rax)
je 0xacbe
jmp 0xacdd
leaq 0x59584(%rip), %rdi     # 0x64249
leaq 0x5947d(%rip), %rsi     # 0x64149
movl $0xb0, %edx
leaq 0x595ec(%rip), %rcx     # 0x642c4
callq 0x6360
cmpl $0x0, 0x1c(%rsp)
jbe 0xace6
jmp 0xad05
leaq 0x59607(%rip), %rdi     # 0x642f4
leaq 0x59455(%rip), %rsi     # 0x64149
movl $0xb1, %edx
leaq 0x595c4(%rip), %rcx     # 0x642c4
callq 0x6360
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
shll $0x3, %eax
xorl %edx, %edx
divl (%rcx)
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jl 0xad5b
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x10ec0
cmpl 0x1c(%rsp), %eax
ja 0xad4c
jmp 0xad5b
jmp 0xad4e
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xad2c
movl 0x10(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0xad67
jmp 0xad86
leaq 0x59590(%rip), %rdi     # 0x642fe
leaq 0x593d4(%rip), %rsi     # 0x64149
movl $0xba, %edx
leaq 0x59543(%rip), %rcx     # 0x642c4
callq 0x6360
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::flushBFfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, unsigned int)
void db::flushBFfile(string filename, const char* sst_bf_p, uint32_t size){
	ofstream outfile(filename, ios::out);
	char buffer[sizeof(unsigned int)];
	memset(buffer, 0, sizeof(unsigned int));
	
	for(int i = 0; i < size; i++){
		memcpy(buffer, &(sst_bf_p[i]), sizeof(char));
		outfile.write(buffer, sizeof(char));
		memset(buffer, 0, sizeof(char));
	}	
	outfile.close();

}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movl %ecx, 0x21c(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x10, %edx
callq 0x68f0
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x62e0
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x21c(%rsp), %eax
jae 0xddfd
movq 0x220(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
movl $0x1, %edx
callq 0x6690
jmp 0xddc5
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x62e0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xdd8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6760
jmp 0xde1b
leaq 0x18(%rsp), %rdi
callq 0x6720
jmp 0xde09
leaq 0x18(%rsp), %rdi
callq 0x6760
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x8(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::flushIndexes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**, int, int)
void db::flushIndexes( string filename, char** indexes, int size, int key_size){
	ofstream outfile(filename, ios::out);
	char buffer[DB_PAGE_SIZE];

	memcpy(buffer, &size, sizeof(unsigned int));
	outfile.write(buffer, sizeof(unsigned int));
	memset(buffer, 0, sizeof(unsigned int));

	memcpy(buffer, &key_size, sizeof(unsigned int));
	outfile.write(buffer, sizeof(unsigned int));
	memset(buffer, 0, sizeof(unsigned int));

	memset(buffer, 0, DB_PAGE_SIZE-2*sizeof(unsigned int));
	outfile.write(buffer, DB_PAGE_SIZE-2*sizeof(unsigned int));

	for(int i = 0 ;i < size; i++){
		memcpy(buffer, indexes[i], key_size);
		outfile.write(buffer, key_size);
		memset(buffer, 0, key_size);
	}
}

// Assembly:
subq $0x1258, %rsp           # imm = 0x1258
movq %rdi, 0x1250(%rsp)
movq %rsi, 0x1248(%rsp)
movq %rdx, 0x1240(%rsp)
movl %ecx, 0x123c(%rsp)
movl %r8d, 0x1238(%rsp)
leaq 0x1038(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x10, %edx
callq 0x68f0
movq 0x18(%rsp), %rdi
movl 0x123c(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
movl $0x4, %edx
callq 0x6690
jmp 0xde96
movl $0x0, 0x30(%rsp)
movl 0x1238(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x1038(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x4, %edx
callq 0x6690
jmp 0xdec2
movl $0x0, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xff8, %edx            # imm = 0xFF8
movq %rdx, 0x10(%rsp)
callq 0x62e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x1038(%rsp), %rdi
callq 0x6690
jmp 0xdefe
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x123c(%rsp), %eax
jge 0xdf97
movq 0x1240(%rsp), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movslq 0x1238(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6440
movq (%rsp), %rsi
movslq 0x1238(%rsp), %rdx
leaq 0x1038(%rsp), %rdi
callq 0x6690
jmp 0xdf59
leaq 0x30(%rsp), %rdi
movslq 0x1238(%rsp), %rdx
xorl %esi, %esi
callq 0x62e0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xdf06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x1038(%rsp), %rdi
callq 0x6760
jmp 0xdfac
leaq 0x1038(%rsp), %rdi
callq 0x6760
addq $0x1258, %rsp           # imm = 0x1258
retq
movq 0x28(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::flushfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void db::flushfile( string filename, vector<string>* table){
	ofstream outfile(filename, ios::out);
	char buffer[DB_PAGE_SIZE];

	int size = table->size();
	memcpy(buffer, &size, sizeof(unsigned int));
	outfile.write(buffer, sizeof(unsigned int));
	memset(buffer, 0, sizeof(unsigned int));

	int key_size = (table->at(0)).size();
	memcpy(buffer, &key_size, sizeof(unsigned int));
	outfile.write(buffer, sizeof(unsigned int));
	memset(buffer, 0, sizeof(unsigned int));

	memset(buffer, 0, DB_PAGE_SIZE-2*sizeof(unsigned int));
	outfile.write(buffer, DB_PAGE_SIZE-2*sizeof(unsigned int));

	for(int i = 0 ;i < size; i++){
		char* str = (char*) malloc(key_size);
		strcpy (str, table->at(i).c_str());
		memcpy(buffer, str, key_size);
		outfile.write(buffer, key_size);
		memset(buffer, 0, key_size);
	}
}

// Assembly:
subq $0x1278, %rsp           # imm = 0x1278
movq %rdi, 0x1270(%rsp)
movq %rsi, 0x1268(%rsp)
movq %rdx, 0x1260(%rsp)
leaq 0x1060(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x10, %edx
callq 0x68f0
movq 0x1260(%rsp), %rdi
callq 0x8020
movq 0x30(%rsp), %rdi
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
movl $0x4, %edx
callq 0x6690
jmp 0xe025
movl $0x0, 0x60(%rsp)
movq 0x1260(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7b30
movq %rax, 0x28(%rsp)
jmp 0xe045
movq 0x28(%rsp), %rdi
callq 0x6390
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x60(%rsp)
leaq 0x1060(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x4, %edx
callq 0x6690
jmp 0xe074
movl $0x0, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0xff8, %edx            # imm = 0xFF8
movq %rdx, 0x20(%rsp)
callq 0x62e0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x1060(%rsp), %rdi
callq 0x6690
jmp 0xe0b0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0xe17d
movslq 0x48(%rsp), %rdi
callq 0x66b0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1260(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0x7b30
movq %rax, 0x10(%rsp)
jmp 0xe0f8
movq 0x10(%rsp), %rdi
callq 0x6250
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x64b0
movq 0x38(%rsp), %rsi
movslq 0x48(%rsp), %rdx
leaq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6440
movq (%rsp), %rsi
movslq 0x48(%rsp), %rdx
leaq 0x1060(%rsp), %rdi
callq 0x6690
jmp 0xe13f
leaq 0x60(%rsp), %rdi
movslq 0x48(%rsp), %rdx
xorl %esi, %esi
callq 0x62e0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xe0b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x1060(%rsp), %rdi
callq 0x6760
jmp 0xe192
leaq 0x1060(%rsp), %rdi
callq 0x6760
addq $0x1278, %rsp           # imm = 0x1278
retq
movq 0x50(%rsp), %rdi
callq 0x6850
nopl (%rax)