LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::info[abi:cxx11]() const
std::string info() const{
		std::stringstream ss;

		ss	<< "Keys (estimated): "	<< list_.getCount(true)	<< '\n'
			<< "Size: "		<< list_.getBytes()	<< '\n'
		;

		return ss.str();
	}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3210
leaq 0x70(%rsp), %rdi
leaq 0x1065a(%rip), %rsi     # 0x19211
callq 0x3300
movq %rax, 0x48(%rsp)
jmp 0x8bc3
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9990
movq %rax, 0x28(%rsp)
jmp 0x8bdc
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rdi
callq 0x30a0
movq %rax, 0x20(%rsp)
jmp 0x8bf2
movq 0x20(%rsp), %rdi
movl $0xa, %esi
callq 0x3370
movq %rax, 0x18(%rsp)
jmp 0x8c08
movq 0x18(%rsp), %rdi
leaq 0x10610(%rip), %rsi     # 0x19224
callq 0x3300
movq %rax, 0x10(%rsp)
jmp 0x8c20
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0x99e0
movq %rax, 0x8(%rsp)
jmp 0x8c34
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x30a0
movq %rax, (%rsp)
jmp 0x8c49
movq (%rsp), %rdi
movl $0xa, %esi
callq 0x3370
jmp 0x8c59
movq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x32f0
jmp 0x8c6a
leaq 0x60(%rsp), %rdi
callq 0x3240
movq 0x38(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3240
movq 0x58(%rsp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nmmmnu[P]HM3/main/dbadapter.h
// Function: DBAdapter<hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>, hm3::tableloader::DirectoryTableLoader>::get[abi:cxx11](StringRef const&) const
std::string get(const StringRef &key) const{
		const auto &p = list_.get(key);
		std::string s = p.getVal();
		std::cout << s << '\n';
		return s;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rsi
movq 0x60(%rsp), %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc980
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movb $0x0, 0x4f(%rsp)
movq 0x58(%rsp), %rdi
callq 0x10f00
movq 0x20(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x4170
jmp 0x8d70
movq 0x20(%rsp), %rsi
movq 0x1b254(%rip), %rdi     # 0x23fd0
callq 0x32b0
movq %rax, 0x8(%rsp)
jmp 0x8d88
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x3370
jmp 0x8d99
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x8ddb
jmp 0x8dd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x8def
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x31e0
jmp 0x8def
movq 0x20(%rsp), %rdi
callq 0x31e0
leaq 0x50(%rsp), %rdi
callq 0x10c90
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x10c90
movq 0x30(%rsp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::getBytes() const
size_t LSMTable<CONTAINER>::getBytes() const{
	size_t result = 0;

	for(const auto &table : container_ )
		result += table.getBytes();

	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9c20
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9c50
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9c80
testb $0x1, %al
jne 0x9a32
jmp 0x9a61
leaq 0x18(%rsp), %rdi
callq 0x9cc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xc950
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x9ce0
jmp 0x9a1d
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::getCountEstimated() const
auto LSMTable<CONTAINER>::getCountEstimated() const -> size_type{
	size_type result = 0;

	for(const auto &table : container_ )
		result += table.getCount();

	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9c20
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9c50
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9c80
testb $0x1, %al
jne 0x9ac2
jmp 0x9af1
leaq 0x18(%rsp), %rdi
callq 0x9cc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x9cd0
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x9ce0
jmp 0x9aad
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/lsmtable.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::getCountReal() const
size_type getCountReal() const{
		// Slooooow....
		size_type count = 0;
		for(const auto &p : *this){
			(void) p;
			++count;
		}

		return count;

		// TODO: difference_type missing...
		// distance(begin(), end());
		//return std::distance(begin(), end());
	}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq $0x0, 0xb8(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x9d40
movq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x9d70
jmp 0x9b51
jmp 0x9b53
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9da0
movb %al, 0x17(%rsp)
jmp 0x9b68
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x9bb2
jmp 0x9b72
leaq 0x30(%rsp), %rdi
callq 0x9ee0
leaq 0x70(%rsp), %rdi
callq 0x9ee0
jmp 0x9bfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x9bf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x9ee0
jmp 0x9bf2
leaq 0x70(%rsp), %rdi
callq 0x9dd0
movq %rax, 0x8(%rsp)
jmp 0x9bc3
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x9e10
jmp 0x9bed
jmp 0x9b53
leaq 0x70(%rsp), %rdi
callq 0x9ee0
jmp 0x9c0e
movq 0xb8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/lsmtable_impl.h
// Function: hm3::LSMTable<std::vector<hm3::DiskTable, std::allocator<hm3::DiskTable>>>::get(StringRef const&) const
Pair LSMTable<CONTAINER>::get(const StringRef &key) const{
	// CONTAINER is responsible for ordering the tables,
	// in correct (probably reverse) order.
	for(const auto &table : container_ ){
		if (Pair pair = table.get(key))
			return pair;
	}

	return nullptr;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9c20
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9c50
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x9c80
testb $0x1, %al
jne 0xc9e0
jmp 0xca5d
leaq 0x30(%rsp), %rdi
callq 0x9cc0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x13cb0
movq 0x8(%rsp), %rdi
callq 0xbed0
testb $0x1, %al
jne 0xca18
jmp 0xca27
movb $0x1, 0x1f(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0xca2f
movl $0x0, 0x18(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0xca40
movq 0x8(%rsp), %rdi
callq 0x10c90
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0xca4c
jmp 0xca4a
jmp 0xca6b
jmp 0xca4e
leaq 0x30(%rsp), %rdi
callq 0x9ce0
jmp 0xc9cb
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10d90
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]HM3/hm3/tableloader/directorytableloader.cc
// Function: hm3::tableloader::DirectoryTableLoader::refresh()
bool DirectoryTableLoader::refresh(){
	container_.clear();

	MyGlob gl;
	if (gl.open(path_) == false)
		return true;

	const auto &files = gl.getData();

	container_.reserve(files.size());

	// order in the iterator, does not matter
	// but order in get, still very important
	auto it_rend = files.rend();
	for (auto it = files.rbegin(); it != it_rend; ++it){
		const auto &filename = *it;

                DiskTable dt;
                dt.open(filename);
                container_.push_back( std::move(dt) );
	}

	return true;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x20, %rdi
callq 0xee30
leaq 0x140(%rsp), %rdi
callq 0xee50
movq 0x18(%rsp), %rsi
leaq 0x130(%rsp), %rdi
callq 0x8cb0
jmp 0xec66
leaq 0x140(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0x10360
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xecb6
movb $0x1, 0x1b7(%rsp)
movl $0x1, 0x120(%rsp)
jmp 0xedf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x128(%rsp)
movl %eax, 0x124(%rsp)
jmp 0xee12
leaq 0x140(%rsp), %rdi
callq 0xee70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rsp)
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x118(%rsp), %rdi
callq 0x49b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xee80
jmp 0xecf8
movq 0x118(%rsp), %rsi
leaq 0x110(%rsp), %rdi
callq 0xefc0
movq 0x118(%rsp), %rsi
leaq 0x108(%rsp), %rdi
callq 0xf010
leaq 0x108(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0xf060
movb %al, 0xf(%rsp)
jmp 0xed3d
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xed4a
jmp 0xede1
leaq 0x108(%rsp), %rdi
callq 0xf090
movq %rax, (%rsp)
jmp 0xed5d
movq (%rsp), %rax
movq %rax, 0x100(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xf0c0
jmp 0xed7a
movq 0x100(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x12f70
jmp 0xed8e
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf1f0
jmp 0xeda3
leaq 0x20(%rsp), %rdi
callq 0x4430
leaq 0x108(%rsp), %rdi
callq 0xf220
jmp 0xedbc
jmp 0xed22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x128(%rsp)
movl %eax, 0x124(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4430
jmp 0xee12
movb $0x1, 0x1b7(%rsp)
movl $0x1, 0x120(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xf250
movb 0x1b7(%rsp), %al
andb $0x1, %al
addq $0x1b8, %rsp            # imm = 0x1B8
retq
leaq 0x140(%rsp), %rdi
callq 0xf250
movq 0x128(%rsp), %rdi
callq 0x34c0
nopl (%rax)
// File: PrzemekWirkus[P]functional-workshop/src/utest.h
// Function: bool CHECK_EQUAL<int, int>(char const*, int, int)
bool CHECK_EQUAL<int, int>(const char *str, int t1, int t2) {
    using namespace std;

    bool result = t1 == t2;
    if (__NOT result) {
        cout << endl << __FILE__ << ": Value mismatch: " << t1 << " != " << t2 << endl;
    }
    cout << str << "\t" << (result ? "OK" : "FAIL") << endl;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x150b
movq 0x4b2b(%rip), %rdi      # 0x5fd8
movq 0x4b0c(%rip), %rsi      # 0x5fc0
callq 0x10d0
movq %rax, %rdi
leaq 0x1b41(%rip), %rsi      # 0x3004
callq 0x10b0
movq %rax, %rdi
leaq 0x1b3e(%rip), %rsi      # 0x3010
callq 0x10b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1120
movq %rax, %rdi
leaq 0x1b37(%rip), %rsi      # 0x3023
callq 0x10b0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1120
movq %rax, %rdi
movq 0x4aba(%rip), %rsi      # 0x5fc0
callq 0x10d0
movq -0x8(%rbp), %rsi
movq 0x4ac2(%rip), %rdi      # 0x5fd8
callq 0x10b0
movq %rax, %rdi
leaq 0x1b03(%rip), %rsi      # 0x3028
callq 0x10b0
movq %rax, %rdi
movb -0x11(%rbp), %cl
leaq 0x1af6(%rip), %rsi      # 0x302d
leaq 0x1aec(%rip), %rax      # 0x302a
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x4a6c(%rip), %rsi      # 0x5fc0
callq 0x10d0
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::~HasPtr()
HasPtr::~HasPtr()
{
	std::cout << "deconstructor." << std::endl;
	if (--*use == 0) {   // if the reference count goes to 0
		std::cout << "delete memory." << std::endl;
		delete ps;       // delete the string
		delete use;      // and the counter
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2d5d(%rip), %rdi      # 0x3fd8
leaq 0xd82(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x10(%rbp)
jmp 0x128d
movq -0x10(%rbp), %rdi
movq 0x2d30(%rip), %rsi      # 0x3fc8
callq 0x10b0
jmp 0x129f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x132c
movq 0x2d1a(%rip), %rdi      # 0x3fd8
leaq 0xd4e(%rip), %rsi       # 0x2013
callq 0x1080
movq %rax, -0x20(%rbp)
jmp 0x12d0
movq -0x20(%rbp), %rdi
movq 0x2ced(%rip), %rsi      # 0x3fc8
callq 0x10b0
jmp 0x12e2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x130a
movq -0x28(%rbp), %rdi
callq 0x1060
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0x10a0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x132a
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x10a0
jmp 0x132c
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x16d0
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr&&)
HasPtr& HasPtr::operator=(HasPtr&& rhs)
{
	std::cout << "move assign." << std::endl;
	if (this != &rhs) {
		if (--*use == 0) {   // do the work of the destructor
			delete ps;
			delete use;
		}
		ps = rhs.ps;         // do the work of the move constructor
		i = rhs.i;
		use = rhs.use;

		rhs.ps = nullptr;
		++*rhs.use;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2c79(%rip), %rdi      # 0x3fd8
leaq 0xcbc(%rip), %rsi       # 0x2022
callq 0x1080
movq %rax, %rdi
movq 0x2c53(%rip), %rsi      # 0x3fc8
callq 0x10b0
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x142b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x13ea
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13c8
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x10a0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x13e8
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x10a0
jmp 0x13ea
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: HasPtr::operator=(HasPtr const&)
HasPtr& HasPtr::operator=(const HasPtr& rhs)
{
	std::cout << "copy assign." << std::endl;
	++*rhs.use;  // increment the use count of the right-hand operand
	if (--*use == 0) {   // then decrement this object's counter
		delete ps;       // if no other users
		delete use;      // free this object's allocated members
	}
	ps = rhs.ps;         // copy data from rhs into this object
	i = rhs.i;
	use = rhs.use;
	return *this;        // return this object
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2b79(%rip), %rdi      # 0x3fd8
leaq 0xbc9(%rip), %rsi       # 0x202f
callq 0x1080
movq %rax, %rdi
movq 0x2b53(%rip), %rsi      # 0x3fc8
callq 0x10b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x14ee
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x14cc
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x10a0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x14ec
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x10a0
jmp 0x14ee
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: f(HasPtr)
HasPtr f(HasPtr hp) // HasPtr passed by value, so it is copied
{
	HasPtr ret;
	ret = hp;        // assignment copies the given HasPtr
	// proces ret
	return ret;      // ret and hp are destroyed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x16e0
jmp 0x155f
leaq -0x38(%rbp), %rdi
callq 0x1060
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1440
jmp 0x1577
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x15ba
jmp 0x15b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1060
jmp 0x15c4
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x1260
jmp 0x15c4
movq -0x58(%rbp), %rdi
callq 0x1260
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1100
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/HasPtrUseCount.cc
// Function: main
int main()
{
	HasPtr h("hi mom!");

	// no new memory is allocated,
	// h and h2 share the same underlying string
	HasPtr h2 = h;

	HasPtr h3 = std::move(h2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1110
movq -0x88(%rbp), %rdx
leaq 0xa43(%rip), %rsi       # 0x203c
leaq -0x38(%rbp), %rdi
callq 0x10d0
jmp 0x1604
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16e0
jmp 0x1613
leaq -0x38(%rbp), %rdi
callq 0x1060
leaq -0x39(%rbp), %rdi
callq 0x10c0
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17a0
jmp 0x1634
leaq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1820
jmp 0x1643
leaq -0x80(%rbp), %rdi
callq 0x1260
leaq -0x68(%rbp), %rdi
callq 0x1260
leaq -0x18(%rbp), %rdi
callq 0x1260
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x168c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1060
leaq -0x39(%rbp), %rdi
callq 0x10c0
jmp 0x16c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x16ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1260
leaq -0x18(%rbp), %rdi
callq 0x1260
movq -0x48(%rbp), %rdi
callq 0x1100
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/fact.cc
// Function: main
int main()
{
	cout << factorial(5) << endl;
	cout << fact(5) << endl;
	cout << factorial(0) << endl;
	cout << fact(0) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x5, %edi
callq 0x12c0
movl %eax, %esi
movq 0x2e06(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2de7(%rip), %rsi      # 0x3fc8
callq 0x1040
movl $0x5, %edi
callq 0x1290
movl %eax, %esi
movq 0x2ddf(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2dc0(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %edi, %edi
callq 0x12c0
movl %eax, %esi
movq 0x2dbb(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2d9c(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %edi, %edi
callq 0x1290
movl %eax, %esi
movq 0x2d97(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2d78(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: gcd(int, int)
int gcd(int v1, int v2)
{
    while (v2) {
        int temp = v2;
        v2 = v1 % v2;
        v1 = temp;
    }
    return v1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1288
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %edx, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x126a
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/LocalMath.cc
// Function: fact(int)
int fact(int val)
{
	int ret = 1; // local variable to hold the result as we calculate it
	while (val > 1) 
		ret *= val--;  // assign ret * val to ret and decrement val
	return ret;        // return the result
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x1, -0x4(%rbp)
jle 0x12b8
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
imull -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x129e
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/unaryOps.cc
// Function: main
int main()
{
	int i = 1024;
	int k = -i; // i is -1024
	
	bool b = true;
	bool b2 = -b; // b2 is true!
	
	cout << b << " " << b2 << " " << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x400, -0x8(%rbp)      # imm = 0x400
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x1, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xe(%rbp)
movb -0xd(%rbp), %al
movq 0x2dd5(%rip), %rdi      # 0x3fd8
andb $0x1, %al
movzbl %al, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xded(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movb -0xe(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xdce(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2d83(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: eschwabe[P]interview-practice/src/convert.cpp
// Function: StringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int StringToInt(const string& str) {

    int value = 0;
    size_t index = 0;
    bool negate_flag = false;

    if(str[index] == '-') {
        negate_flag = true;
        index++;
    }

    for(; index < str.size(); ++index) {
        value *= 10;
        value += str[index] - '0';
    }

    if(negate_flag) {
        value = -value;
    }

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2384
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2386
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x23d1
imull $0xa, -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
movsbl (%rax), %eax
subl $0x30, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2386
testb $0x1, -0x19(%rbp)
je 0x23df
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/convert.cpp
// Function: IntToString[abi:cxx11](int const&)
string IntToString(const int& value) {

    string str;
    int tmp = value;
    bool negate_flag = false;

    if(tmp < 0) {
        negate_flag = true;
        tmp = -tmp;
    }

    if(tmp == 0) {
        str.insert(0, 1, '0');
    } else {
        while(tmp > 0) {
            char c = (tmp % 10) + '0';
            str.insert(0, 1, c);
            tmp /= 10;
        }
    }

    if(negate_flag) {
        str.insert(0, 1, '-');
    }

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2160
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x2433
movb $0x1, -0x19(%rbp)
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x246e
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x30, %ecx
callq 0x21f0
jmp 0x2452
jmp 0x24c8
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2070
jmp 0x2506
jmp 0x2470
cmpl $0x0, -0x18(%rbp)
jle 0x24c6
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rcx
movl %ecx, %eax
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x22, %rdx
addl %ecx, %edx
addl %edx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
addb $0x30, %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x21f0
jmp 0x24b6
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x2470
jmp 0x24c8
testb $0x1, -0x19(%rbp)
je 0x24e9
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x2d, %ecx
callq 0x21f0
jmp 0x24e7
jmp 0x24e9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x24fc
movq -0x40(%rbp), %rdi
callq 0x2070
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21b0
nop
// File: mlugo2[P]SunshineGPU/inc/stringproc.h
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>> const&)
void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters )
{
	// Skip delimiters at beginning.
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (std::string::npos != pos || std::string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3260
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x32b0
movq %rax, 0x40(%rsp)
movb $0x1, %al
movq $-0x1, %rcx
cmpq 0x40(%rsp), %rcx
movb %al, 0x13(%rsp)
jne 0x36eb
movq $-0x1, %rax
cmpq 0x48(%rsp), %rax
setne %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x36f8
jmp 0x378d
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
subq %rdx, %rcx
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3330
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5170
jmp 0x3732
leaq 0x20(%rsp), %rdi
callq 0x31e0
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x3260
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x32b0
movq %rax, 0x40(%rsp)
jmp 0x36c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x31e0
jmp 0x3792
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: mlugo2[P]SunshineGPU/inc/main.h
// Function: vertex_shader_interface(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<unsigned long long, std::allocator<unsigned long long>>*)
void vertex_shader_interface(std::string fileName, 
	std::vector<unsigned long long int > *vertexShader )
{
	// Opening file
	std::ifstream myFile;
	myFile.open(fileName.data());

	// Read file into vector for easier processing
	std::vector<std::string> data;
	std::string line;
	while( myFile.good() )
	{
		getline(myFile, line);
		line[line.length()] = '\0';
		data.push_back(line);
	}

	myFile.close();

	for ( auto i : data )
	{
		vertexShader->push_back(stoull(i,0,0));
	}

}

// Assembly:
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdi, 0x28(%rsp)
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3390
movq 0x28(%rsp), %rdi
callq 0x3190
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x31f0
jmp 0x427c
leaq 0x98(%rsp), %rdi
callq 0x51a0
leaq 0x78(%rsp), %rdi
callq 0x33c0
movq 0xc0(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0xc0(%rsp,%rax), %rdi
callq 0x3450
movb %al, 0x27(%rsp)
jmp 0x42b2
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x42bf
jmp 0x4349
leaq 0xc0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x30b0
jmp 0x42d3
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3400
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x34f0
movq %rax, 0x18(%rsp)
jmp 0x42f6
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x51b0
jmp 0x4312
jmp 0x4293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x446b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x4454
leaq 0xc0(%rsp), %rdi
callq 0x30c0
jmp 0x4358
leaq 0x98(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x52e0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x5490
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x54c0
testb $0x1, %al
jne 0x439b
jmp 0x4428
leaq 0x68(%rsp), %rdi
callq 0x5500
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x3130
jmp 0x43b4
movq 0x2c8(%rsp), %rax
movq %rax, (%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x40(%rsp), %rdi
callq 0x5880
movq %rax, 0x8(%rsp)
jmp 0x43d5
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x5850
jmp 0x43ef
leaq 0x40(%rsp), %rdi
callq 0x31e0
leaq 0x68(%rsp), %rdi
callq 0x5560
jmp 0x4383
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31e0
jmp 0x4454
leaq 0x78(%rsp), %rdi
callq 0x31e0
leaq 0x98(%rsp), %rdi
callq 0x57f0
leaq 0xc0(%rsp), %rdi
callq 0x30d0
addq $0x2d8, %rsp            # imm = 0x2D8
retq
leaq 0x78(%rsp), %rdi
callq 0x31e0
leaq 0x98(%rsp), %rdi
callq 0x57f0
leaq 0xc0(%rsp), %rdi
callq 0x30d0
movq 0xb8(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/inc/screen.h
// Function: init_screen()
bool init_screen() {

	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init( SDL_INIT_VIDEO) < 0) {
		printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
		success = false;
	}
	else {

		//Set texture filtering to linear
		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
		{
			printf( "Warning: Linear texture filtering not enabled!" );
		}

		// Create window
		gWindow = SDL_CreateWindow("GPU", SDL_WINDOWPOS_UNDEFINED,
			SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );

		if (gWindow == NULL) {
			printf("Window could not created! SDL_Error: %s\n", SDL_GetError());
			success = false;
		}
		else {

			// Create renderer for window
			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED);
			if ( gRenderer == NULL ) {
				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
				success = false;
			}
			else {
				// Initialize renderer color
				SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			}
		}
	}

	return success;
}

// Assembly:
pushq %rax
movb $0x1, 0x7(%rsp)
movl $0x20, %edi
callq 0x32c0
cmpl $0x0, %eax
jge 0x48c5
callq 0x3220
movq %rax, %rsi
leaq 0x1079e(%rip), %rdi     # 0x15052
movb $0x0, %al
callq 0x3060
movb $0x0, 0x7(%rsp)
jmp 0x499d
leaq 0x107af(%rip), %rdi     # 0x1507b
leaq 0x107c1(%rip), %rsi     # 0x15094
callq 0x3480
cmpl $0x0, %eax
jne 0x48eb
leaq 0x107b2(%rip), %rdi     # 0x15096
movb $0x0, %al
callq 0x3060
leaq 0x107d3(%rip), %rdi     # 0x150c5
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x280, %r8d            # imm = 0x280
movl $0x4, %r9d
movl %edx, %esi
callq 0x3070
movq %rax, 0x17992(%rip)     # 0x1c2a8
cmpq $0x0, 0x1798a(%rip)     # 0x1c2a8
jne 0x493d
callq 0x3220
movq %rax, %rsi
leaq 0x1079a(%rip), %rdi     # 0x150c9
movb $0x0, %al
callq 0x3060
movb $0x0, 0x7(%rsp)
jmp 0x499b
movq 0x17964(%rip), %rdi     # 0x1c2a8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x3040
movq %rax, 0x1795e(%rip)     # 0x1c2b8
cmpq $0x0, 0x17956(%rip)     # 0x1c2b8
jne 0x4981
callq 0x3220
movq %rax, %rsi
leaq 0x1077f(%rip), %rdi     # 0x150f2
movb $0x0, %al
callq 0x3060
movb $0x0, 0x7(%rsp)
jmp 0x4999
movq 0x17930(%rip), %rdi     # 0x1c2b8
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x33d0
jmp 0x499b
jmp 0x499d
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/inc/screen.h
// Function: thread_screen(unsigned char (*) [800][3])
void thread_screen( unsigned char FB[][SCREEN_WIDTH][3])
{
	// Event handler
	SDL_Event e;

	// Accessing each byte in vram
	int x, y;

	// Start up SDL and create window
	if ( !init_screen() ) {
		std::cout << "Failed to Initialize!\n";
	}
	else {
		// While application is running
		while( !m_quit ) {

			// Handle events on queue
			while( SDL_PollEvent(&e) != 0) {
				// User requests quit
				if ( e.type == SDL_QUIT ) { m_quit = true; }
			}

			// Clear screen
			SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			SDL_RenderClear( gRenderer );

			// Render to screen given frame buffer
			for (y = 0; y < SCREEN_HEIGHT; y++) {
				for (x = 0; x < SCREEN_WIDTH; x++) {

					// Render pixel
					SDL_Rect pixel = { x, y, 1, 1};

					// Draw to the screen
					SDL_SetRenderDrawColor( gRenderer, 
							FB[y][x][0], 
							FB[y][x][1], 
							FB[y][x][2], 
							255
						);
					SDL_RenderFillRect( gRenderer, &pixel );
				}
			}

			// Update screen
			SDL_RenderPresent( gRenderer );
		}

		// Free resources and close SDL
		close_sdl();
		
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
callq 0x4890
testb $0x1, %al
jne 0x49fa
movq 0x175d7(%rip), %rdi     # 0x1bfc0
leaq 0x10730(%rip), %rsi     # 0x15120
callq 0x3300
jmp 0x4b68
jmp 0x49fc
movb 0x1789f(%rip), %al      # 0x1c2a1
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a0d
jmp 0x4b63
jmp 0x4a0f
leaq 0x18(%rsp), %rdi
callq 0x31c0
cmpl $0x0, %eax
je 0x4a31
cmpl $0x100, 0x18(%rsp)      # imm = 0x100
jne 0x4a2f
movb $0x1, 0x17872(%rip)     # 0x1c2a1
jmp 0x4a0f
movq 0x17880(%rip), %rdi     # 0x1c2b8
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x33d0
movq 0x17868(%rip), %rdi     # 0x1c2b8
callq 0x32f0
movl $0x0, 0x10(%rsp)
cmpl $0x280, 0x10(%rsp)      # imm = 0x280
jge 0x4b52
movl $0x0, 0x14(%rsp)
cmpl $0x320, 0x14(%rsp)      # imm = 0x320
jge 0x4b40
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x1, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x17811(%rip), %rdi     # 0x1c2b8
movq 0x50(%rsp), %rax
movslq 0x10(%rsp), %rcx
imulq $0x960, %rcx, %rcx      # imm = 0x960
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movb (%rax), %dl
movq 0x50(%rsp), %rax
movslq 0x10(%rsp), %rcx
imulq $0x960, %rcx, %rcx      # imm = 0x960
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movb 0x1(%rax), %cl
movq 0x50(%rsp), %rax
movslq 0x10(%rsp), %rsi
imulq $0x960, %rsi, %rsi      # imm = 0x960
addq %rsi, %rax
movslq 0x14(%rsp), %rsi
imulq $0x3, %rsi, %rsi
addq %rsi, %rax
movl $0xff, %r8d
movzbl %dl, %esi
movzbl %cl, %edx
movzbl 0x2(%rax), %ecx
callq 0x33d0
movq 0x17790(%rip), %rdi     # 0x1c2b8
movq %rsp, %rsi
callq 0x3160
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a73
jmp 0x4b42
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4a5d
movq 0x1775f(%rip), %rdi     # 0x1c2b8
callq 0x3090
jmp 0x49fc
callq 0x49b0
addq $0x58, %rsp
retq
nopl (%rax)
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::load_const_mem(std::vector<float, std::allocator<float>>)
void gpu::load_const_mem(vector<float> constants)
{
	// Load this baby up.
	int index = 0;
	for ( int i = 0; i < constants.size(); i += 4 )
	{
		main_mem[CONST_REG][index].x = constants[i];
		main_mem[CONST_REG][index].y = constants[i+1];
		main_mem[CONST_REG][index].z = constants[i+2];
		main_mem[CONST_REG][index].w = constants[i+3];
		index++;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x8490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xd0bb
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x14ad0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movss (%rcx), %xmm0
addq $0x7d6c0, %rax          # imm = 0x7D6C0
addq $0x200, %rax            # imm = 0x200
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, 0xc(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x14ad0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movss (%rcx), %xmm0
addq $0x7d6c0, %rax          # imm = 0x7D6C0
addq $0x200, %rax            # imm = 0x200
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, 0x8(%rax)
movl 0x20(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x14ad0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movss (%rcx), %xmm0
addq $0x7d6c0, %rax          # imm = 0x7D6C0
addq $0x200, %rax            # imm = 0x200
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, 0x4(%rax)
movl 0x20(%rsp), %eax
addl $0x3, %eax
movslq %eax, %rsi
callq 0x14ad0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movss (%rcx), %xmm0
addq $0x7d6c0, %rax          # imm = 0x7D6C0
addq $0x200, %rax            # imm = 0x200
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x4, %eax
movl %eax, 0x20(%rsp)
jmp 0xcf8d
addq $0x38, %rsp
retq
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMin(__u128*)
int gpu::getXMin(u128 v[])
{
	int min = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x < min)
			min = v[i].x;
	}	

	return min;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cvttss2si 0xc(%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x3, -0x18(%rsp)
jge 0x13861
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0xc(%rax), %xmm1
cvtsi2ssl -0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x13852
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cvttss2si 0xc(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x13854
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x13810
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMax(__u128*)
int gpu::getXMax(u128 v[])
{
	int max = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x > max)
			max = v[i].x;
	}	

	return max;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cvttss2si 0xc(%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x3, -0x18(%rsp)
jge 0x138e1
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0xc(%rax), %xmm0
cvtsi2ssl -0x14(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x138d2
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cvttss2si 0xc(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x138d4
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x13890
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMin(__u128*)
int gpu::getYMin(u128 v[])
{
	int min = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y < min)
			min = v[i].y;
	}	

	return min;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cvttss2si 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x3, -0x18(%rsp)
jge 0x13961
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm1
cvtsi2ssl -0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x13952
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cvttss2si 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x13954
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x13910
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMax(__u128*)
int gpu::getYMax(u128 v[])
{
	int max = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y > max)
			max = v[i].y;
	}	

	return max;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cvttss2si 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x3, -0x18(%rsp)
jge 0x139e1
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm0
cvtsi2ssl -0x14(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x139d2
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cvttss2si 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x139d4
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x13990
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getZ(__u128*, int, int)
int gpu::getZ(u128 v[], int x, int y)
{
	// if all z's same return one of them
	if (v[0].z == v[1].z && v[1].z == v[2].z)
		return v[0].z;

	// if not, then do calculations
	// plane equation
	return
	( -((v[0].z*( v[1].x - v[2].x )+
		   v[1].z*( v[2].x - v[0].x )+
		   v[2].z*( v[0].x - v[1].x)) * x +
	
		  (v[0].y*( v[1].z - v[2].z )+
		   v[1].y*( v[2].z - v[0].z )+
		   v[2].y*( v[0].z - v[1].z)) * y) /

		(v[0].x*( v[1].y - v[2].y )+
		   v[1].x*( v[2].y - v[0].y )+
		   v[2].x*( v[0].y - v[1].y))

	);

}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl %ecx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rsp), %rax
ucomiss 0x14(%rax), %xmm0
jne 0x13ac3
jp 0x13ac3
movq -0x18(%rsp), %rax
movss 0x14(%rax), %xmm0
movq -0x18(%rsp), %rax
ucomiss 0x24(%rax), %xmm0
jne 0x13ac3
jp 0x13ac3
movq -0x18(%rsp), %rax
cvttss2si 0x4(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x13c3e
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x1c(%rax), %xmm2
movq -0x18(%rsp), %rax
subss 0x2c(%rax), %xmm2
movq -0x18(%rsp), %rax
movss 0x14(%rax), %xmm0
movq -0x18(%rsp), %rax
movss 0x2c(%rax), %xmm3
movq -0x18(%rsp), %rax
subss 0xc(%rax), %xmm3
mulss %xmm3, %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rsp), %rax
movss 0x24(%rax), %xmm0
movq -0x18(%rsp), %rax
movss 0xc(%rax), %xmm2
movq -0x18(%rsp), %rax
subss 0x1c(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtsi2ssl -0x1c(%rsp), %xmm2
movq -0x18(%rsp), %rax
movss 0x8(%rax), %xmm3
movq -0x18(%rsp), %rax
movss 0x14(%rax), %xmm4
movq -0x18(%rsp), %rax
subss 0x24(%rax), %xmm4
movq -0x18(%rsp), %rax
movss 0x18(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x24(%rax), %xmm5
movq -0x18(%rsp), %rax
subss 0x4(%rax), %xmm5
mulss %xmm5, %xmm1
mulss %xmm4, %xmm3
addss %xmm1, %xmm3
movq -0x18(%rsp), %rax
movss 0x28(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x4(%rax), %xmm4
movq -0x18(%rsp), %rax
subss 0x14(%rax), %xmm4
mulss %xmm4, %xmm1
addss %xmm3, %xmm1
cvtsi2ssl -0x20(%rsp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rsp), %rax
movss 0xc(%rax), %xmm2
movq -0x18(%rsp), %rax
movss 0x18(%rax), %xmm3
movq -0x18(%rsp), %rax
subss 0x28(%rax), %xmm3
movq -0x18(%rsp), %rax
movss 0x1c(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x28(%rax), %xmm4
movq -0x18(%rsp), %rax
subss 0x8(%rax), %xmm4
mulss %xmm4, %xmm1
mulss %xmm3, %xmm2
addss %xmm1, %xmm2
movq -0x18(%rsp), %rax
movss 0x2c(%rax), %xmm1
movq -0x18(%rsp), %rax
movss 0x8(%rax), %xmm3
movq -0x18(%rsp), %rax
subss 0x18(%rax), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: loverszhaokai[P]TypoCheck/src/typo_check.cc
// Function: main
int main(int argc, char **argv)
{
	if (argc != 3) {
		usage();
		return -1;
	}

	cout << "Checking typos, please wait a moment" << endl;

	init();

	init_typos(string(argv[1]));

	print_typo_info();

	search_typo_per_file(string(argv[2]));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x2590
callq 0x26e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26bf
movq 0x6a41(%rip), %rdi      # 0x8fd8
leaq 0x3a66(%rip), %rsi      # 0x6004
callq 0x21c0
movq %rax, %rdi
movq 0x6a1b(%rip), %rsi      # 0x8fc8
callq 0x2200
callq 0x2aa0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2320
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2750
jmp 0x25e3
leaq -0x30(%rbp), %rdi
callq 0x2b20
jmp 0x25ee
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x2220
callq 0x3690
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2320
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x2750
jmp 0x263d
leaq -0x68(%rbp), %rdi
callq 0x3140
jmp 0x2648
leaq -0x68(%rbp), %rdi
callq 0x2120
leaq -0x69(%rbp), %rdi
callq 0x2220
movl $0x0, -0x4(%rbp)
jmp 0x26bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x2220
jmp 0x26cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x26b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
leaq -0x69(%rbp), %rdi
callq 0x2220
jmp 0x26cb
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: loverszhaokai[P]TypoCheck/src/typo_check.cc
// Function: usage()
static void usage()
{
	cout << endl;
	cout << "usage:" << endl;
	cout << "\ttypochecker typos checkfile1" << endl;
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x68ed(%rip), %rdi      # 0x8fd8
movq 0x68d6(%rip), %rsi      # 0x8fc8
callq 0x2200
movq 0x68da(%rip), %rdi      # 0x8fd8
leaq 0x3924(%rip), %rsi      # 0x6029
callq 0x21c0
movq %rax, %rdi
movq 0x68b4(%rip), %rsi      # 0x8fc8
callq 0x2200
movq 0x68b8(%rip), %rdi      # 0x8fd8
leaq 0x3909(%rip), %rsi      # 0x6030
callq 0x21c0
movq %rax, %rdi
movq 0x6892(%rip), %rsi      # 0x8fc8
callq 0x2200
movq 0x6896(%rip), %rdi      # 0x8fd8
movq 0x687f(%rip), %rsi      # 0x8fc8
callq 0x2200
popq %rbp
retq