LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: theuni[P]libutreexo/crypto/sha256_sse41.cpp
// Function: sha256d64_sse41::(anonymous namespace)::Read4(unsigned char const*, int)
__m128i inline Read4(const unsigned char* chunk, int offset) {
    __m128i ret = _mm_set_epi32(
        ReadLE32(chunk + 0 + offset),
        ReadLE32(chunk + 64 + offset),
        ReadLE32(chunk + 128 + offset),
        ReadLE32(chunk + 192 + offset)
    );
    return _mm_shuffle_epi8(ret, _mm_set_epi32(0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x6c(%rbp), %rax
addq %rax, %rdi
callq 0x51120
movl %eax, -0x8c(%rbp)
movq -0x68(%rbp), %rax
movslq -0x6c(%rbp), %rcx
leaq 0x40(%rax,%rcx), %rdi
callq 0x51120
movl %eax, -0x88(%rbp)
movq -0x68(%rbp), %rax
movslq -0x6c(%rbp), %rcx
leaq 0x80(%rax,%rcx), %rdi
callq 0x51120
movl %eax, -0x84(%rbp)
movq -0x68(%rbp), %rax
movslq -0x6c(%rbp), %rcx
leaq 0xc0(%rax,%rcx), %rdi
callq 0x51120
movl -0x8c(%rbp), %esi
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %ecx
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %eax
movd -0x30(%rbp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps -0x40(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movaps -0x80(%rbp), %xmm1
movl $0xc0d0e0f, -0x44(%rbp) # imm = 0xC0D0E0F
movl $0x8090a0b, -0x48(%rbp) # imm = 0x8090A0B
movl $0x4050607, -0x4c(%rbp) # imm = 0x4050607
movl $0x10203, -0x50(%rbp)   # imm = 0x10203
movl -0x4c(%rbp), %edx
movl -0x48(%rbp), %ecx
movl -0x44(%rbp), %eax
movd -0x50(%rbp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movdqa %xmm0, -0x60(%rbp)
movdqa -0x60(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm0
movdqa -0x20(%rbp), %xmm1
pshufb %xmm1, %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: theuni[P]libutreexo/crypto/sha256_sse41.cpp
// Function: sha256d64_sse41::(anonymous namespace)::Write4(unsigned char*, int, long long vector[2])
void inline Write4(unsigned char* out, int offset, __m128i v) {
    v = _mm_shuffle_epi8(v, _mm_set_epi32(0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL));
    WriteLE32(out + 0 + offset, _mm_extract_epi32(v, 3));
    WriteLE32(out + 32 + offset, _mm_extract_epi32(v, 2));
    WriteLE32(out + 64 + offset, _mm_extract_epi32(v, 1));
    WriteLE32(out + 96 + offset, _mm_extract_epi32(v, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movl %esi, -0x4c(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm1
movl $0xc0d0e0f, -0x24(%rbp) # imm = 0xC0D0E0F
movl $0x8090a0b, -0x28(%rbp) # imm = 0x8090A0B
movl $0x4050607, -0x2c(%rbp) # imm = 0x4050607
movl $0x10203, -0x30(%rbp)   # imm = 0x10203
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %eax
movd -0x30(%rbp), %xmm0
pinsrd $0x1, %edx, %xmm0
pinsrd $0x2, %ecx, %xmm0
pinsrd $0x3, %eax, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps -0x40(%rbp), %xmm0
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x4c(%rbp), %rax
addq %rax, %rdi
movl -0x54(%rbp), %esi
callq 0x51160
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
leaq 0x20(%rax,%rcx), %rdi
movl -0x58(%rbp), %esi
callq 0x51160
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
leaq 0x40(%rax,%rcx), %rdi
movl -0x5c(%rbp), %esi
callq 0x51160
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
leaq 0x60(%rax,%rcx), %rdi
movl -0x60(%rbp), %esi
callq 0x51160
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: PRDeving[P]CheckMyTags/src/checkmytags.cpp
// Function: getLookFor(char*)
void getLookFor(char file[]){
    if(file != NULL)
        lookforfile = file;

    cout << lookforfile << endl;

    string line;
    ifstream is(lookforfile.c_str());

    while(getline(is, line)){
        Tag item;
        item.name = line;
        item.cname = line.insert( 1, "/");
        item.count = 0;
        tags.push_back(item);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2506
movq -0x8(%rbp), %rsi
leaq 0x4c97(%rip), %rdi      # 0x7198
callq 0x2210
movq 0x4acb(%rip), %rdi      # 0x6fd8
leaq 0x4c84(%rip), %rsi      # 0x7198
movq %rsi, -0x290(%rbp)
callq 0x2160
movq %rax, %rdi
movq 0x4a96(%rip), %rsi      # 0x6fc0
callq 0x21a0
leaq -0x28(%rbp), %rdi
callq 0x2220
movq -0x290(%rbp), %rdi
callq 0x20b0
movq %rax, %rsi
leaq -0x230(%rbp), %rdi
movl $0x8, %edx
callq 0x22b0
jmp 0x255a
jmp 0x255c
leaq -0x230(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2050
movq %rax, -0x298(%rbp)
jmp 0x2575
movq -0x298(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2200
movb %al, -0x299(%rbp)
jmp 0x2593
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x25a2
jmp 0x2672
leaq -0x288(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
callq 0x2ea0
movq -0x2a8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2030
jmp 0x25c7
leaq 0x1a54(%rip), %rdx      # 0x4022
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2060
movq %rax, -0x2b0(%rbp)
jmp 0x25e5
movq -0x2b0(%rbp), %rsi
leaq -0x268(%rbp), %rdi
callq 0x2030
jmp 0x25fa
movl $0x0, -0x248(%rbp)
leaq 0x4bad(%rip), %rdi      # 0x71b8
leaq -0x288(%rbp), %rsi
callq 0x2ed0
jmp 0x2619
leaq -0x288(%rbp), %rdi
callq 0x2f40
jmp 0x255c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x269c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x2690
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2f40
jmp 0x2690
leaq -0x230(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0x22e8
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x230(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0x22e8
movq -0x238(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: PRDeving[P]CheckMyTags/src/checkmytags.cpp
// Function: countSubstring(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>>)
int countSubstring(const string* str, const string sub){
    if (sub.length() == 0) return 0;
    int count = 0;
    for (size_t offset = str->find(sub); offset != std::string::npos;
    offset = str->find(sub, offset + sub.length())){
        ++count;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x2240
cmpq $0x0, %rax
jne 0x26f3
movl $0x0, -0x4(%rbp)
jmp 0x2758
movq -0x30(%rbp), %rsi
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x2752
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2240
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq %rax, %rdx
callq 0x22d0
movq %rax, -0x28(%rbp)
jmp 0x270f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: PRDeving[P]CheckMyTags/src/checkmytags.cpp
// Function: checkIf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void checkIf(string* line){
    for(unsigned int x = 0; x < tags.size(); x++){
        if(line->find(tags[x].name) != string::npos){
            tags[x].count += countSubstring(line, tags[x].name);
        }
        if(line->find(tags[x].cname) != string::npos){
            tags[x].count -= countSubstring(line, tags[x].cname);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x58(%rbp)
leaq 0x4a24(%rip), %rdi      # 0x71b8
callq 0x2f70
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x28d7
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x49fb(%rip), %rdi      # 0x71b8
callq 0x2fa0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x2830
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x49cc(%rip), %rdi      # 0x71b8
callq 0x2fa0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x20c0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x26c0
movl %eax, -0x64(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x499f(%rip), %rdi      # 0x71b8
callq 0x2fa0
movl -0x64(%rbp), %ecx
addl 0x40(%rax), %ecx
movl %ecx, 0x40(%rax)
leaq -0x30(%rbp), %rdi
callq 0x22e8
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x4974(%rip), %rdi      # 0x71b8
callq 0x2fa0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x28c7
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x493e(%rip), %rdi      # 0x71b8
callq 0x2fa0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x50(%rbp), %rdi
callq 0x20c0
movq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x26c0
movl %eax, -0x7c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x490a(%rip), %rdi      # 0x71b8
callq 0x2fa0
movl -0x7c(%rbp), %edx
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
leaq -0x50(%rbp), %rdi
callq 0x22e8
jmp 0x28c9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2786
addq $0x90, %rsp
popq %rbp
retq
// File: bsaikiran618[P]mandelbrot-set-viewer/main.cpp
// Function: main
int main()
{
	try
	{
		Window appWindow("SK's Mandelbrot Set Viewer", SDL_WINDOW_SHOWN);
		appWindow.startEventLoop();
	}
	catch(std::string errMsg)
	{
		std::cerr << errMsg << std::endl;
		exit(-1);
	}
	catch(...)
	{
		std::cerr << "An unknown error occured!" << std::endl;
		exit(-1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22e0
movq -0x80(%rbp), %rdx
leaq 0x1adf(%rip), %rsi      # 0x4039
leaq -0x40(%rbp), %rdi
callq 0x26e0
jmp 0x2565
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x4, %edx
callq 0x2e80
jmp 0x2579
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x41(%rbp), %rdi
callq 0x2210
leaq -0x20(%rbp), %rdi
callq 0x2f90
jmp 0x2596
jmp 0x26ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x25be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x41(%rbp), %rdi
callq 0x2210
jmp 0x25d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x2643
movq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2270
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0x25ff
movq -0x88(%rbp), %rdi
callq 0x20a0
movq 0x39de(%rip), %rdi      # 0x5ff0
leaq -0x78(%rbp), %rsi
callq 0x2190
movq %rax, -0x90(%rbp)
jmp 0x2624
movq -0x90(%rbp), %rdi
movq 0x3986(%rip), %rsi      # 0x5fb8
callq 0x21f0
jmp 0x2639
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2250
movq -0x50(%rbp), %rdi
callq 0x20a0
movq 0x399d(%rip), %rdi      # 0x5ff0
leaq 0x19fa(%rip), %rsi      # 0x4054
callq 0x21e0
movq %rax, -0x98(%rbp)
jmp 0x2668
movq -0x98(%rbp), %rdi
movq 0x3942(%rip), %rsi      # 0x5fb8
callq 0x21f0
jmp 0x267d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2250
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x22b0
jmp 0x269a
jmp 0x26c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2120
callq 0x22b0
jmp 0x26b8
jmp 0x26c5
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x2790
nopw %cs:(%rax,%rax)
// File: bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::drawAxes(Cartesian2DPlane*)
void Window::drawAxes( Cartesian2DPlane *plane )
{
	Cartesian2DPoint leftExtreme	(double(0),	-1000,	plane);
	Cartesian2DPoint rightExtreme	(double(0),	1000,	plane);
	Cartesian2DPoint topExtreme		(double(1000), 0,		plane);
	Cartesian2DPoint bottomExtreme	(double(-1000),0, 	plane);

	SDL_SetRenderDrawColor(screenRenderer, 120,120,120,SDL_ALPHA_OPAQUE);
	//The X axis
	SDL_RenderDrawLine(screenRenderer, leftExtreme.getOnScreenX(), leftExtreme.getOnScreenY(),	
										rightExtreme.getOnScreenX(), rightExtreme.getOnScreenY());
	//The Y axis
	SDL_RenderDrawLine(screenRenderer, topExtreme.getOnScreenX(), topExtreme.getOnScreenY(),
										bottomExtreme.getOnScreenX(), bottomExtreme.getOnScreenY());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x1637(%rip), %xmm1     # 0x4098
callq 0x31c0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x1627(%rip), %xmm1     # 0x40a0
callq 0x31c0
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movsd 0x1612(%rip), %xmm0     # 0x40a0
xorps %xmm1, %xmm1
callq 0x31c0
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movsd 0x15f2(%rip), %xmm0     # 0x4098
xorps %xmm1, %xmm1
callq 0x31c0
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x78, %ecx
movl $0xff, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq 0x2280
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3360
movl %eax, -0x9c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3410
movl %eax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movl %eax, -0x94(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3410
movq -0xa8(%rbp), %rdi
movl -0x9c(%rbp), %esi
movl -0x98(%rbp), %edx
movl -0x94(%rbp), %ecx
movl %eax, %r8d
callq 0x2090
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3360
movl %eax, -0x7c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3410
movl %eax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3360
movl %eax, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3410
movq -0x88(%rbp), %rdi
movl -0x7c(%rbp), %esi
movl -0x78(%rbp), %edx
movl -0x74(%rbp), %ecx
movl %eax, %r8d
callq 0x2090
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::Window(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Window::Window(std::string windowTitle, uint64_t flags)
{	
		if(SDL_Init(SDL_INIT_VIDEO) < 0) throw "Couldn't initialize SDL Video!";

		if((window = SDL_CreateWindow(windowTitle.c_str(), WINDOW_X, WINDOW_Y, SCREEN_W, SCREEN_H, flags)) == NULL)
			throw "Couldn't create SDL window!";

		//windowSurface = SDL_GetWindowSurface(window);

		if((screenRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED)) == NULL)
			throw "Couldn't create SDL Renderer!";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x21a0
cmpl $0x0, %eax
jge 0x2ed6
movl $0x8, %edi
callq 0x20f0
movq %rax, %rdi
leaq 0x1203(%rip), %rax      # 0x40c6
movq %rax, (%rdi)
movq 0x30f3(%rip), %rsi      # 0x5fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x22c0
movq -0x28(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl %eax, %r9d
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x384, %r8d            # imm = 0x384
movl %edx, %esi
movl %r8d, %ecx
callq 0x2040
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x2f32
movl $0x8, %edi
callq 0x20f0
movq %rax, %rdi
leaq 0x11c6(%rip), %rax      # 0x40e5
movq %rax, (%rdi)
movq 0x3097(%rip), %rsi      # 0x5fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x22c0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2030
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x2f7d
movl $0x8, %edi
callq 0x20f0
movq %rax, %rdi
leaq 0x1197(%rip), %rax      # 0x4101
movq %rax, (%rdi)
movq 0x304c(%rip), %rsi      # 0x5fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x22c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bsaikiran618[P]mandelbrot-set-viewer/Window.cpp
// Function: Window::startEventLoop()
void Window::startEventLoop()
{
		SDL_Event e;
		bool appQuit = false;
		bool changed = false;
		srand(42);
		
		Cartesian2DPlane plane(SCREEN_W, SCREEN_H, 150);
		drawScreen(&plane);
		while(!appQuit)
		{
			changed = false;
			while(SDL_PollEvent(&e))
			{
				if(e.type == SDL_QUIT)
				{
					appQuit = true;
					break;
				}
				else if(e.type == SDL_KEYDOWN)
				{
					switch(e.key.keysym.sym)
					{
						case SDLK_UP: 		plane.translateUp();	changed = true;break;
						case SDLK_DOWN: 	plane.translateDown();	changed = true;break;
						case SDLK_LEFT: 	plane.translateLeft();	changed = true;break;
						case SDLK_RIGHT: 	plane.translateRight();	changed = true;break;
						case SDLK_z: 	plane.zoomIn();			changed = true;break;
						case SDLK_x:	plane.zoomOut();		changed = true;break;
					}
				}
			}
			if(changed) drawScreen(&plane);
		}
		//event loop ends.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x41(%rbp)
movb $0x0, -0x42(%rbp)
movl $0x2a, %edi
callq 0x21d0
leaq -0x78(%rbp), %rdi
movl $0x384, %edx            # imm = 0x384
movsd 0x10e6(%rip), %xmm0     # 0x40b0
movq %rdx, %rsi
callq 0x34d0
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2ba0
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2fed
jmp 0x30f8
movb $0x0, -0x42(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
cmpl $0x0, %eax
je 0x30e0
cmpl $0x100, -0x40(%rbp)     # imm = 0x100
jne 0x3015
movb $0x1, -0x41(%rbp)
jmp 0x30e0
cmpl $0x300, -0x40(%rbp)     # imm = 0x300
jne 0x30d9
movl -0x2c(%rbp), %eax
movl %eax, -0x84(%rbp)
subl $0x78, %eax
je 0x30ca
jmp 0x3036
movl -0x84(%rbp), %eax
subl $0x7a, %eax
je 0x30bb
jmp 0x3043
movl -0x84(%rbp), %eax
subl $0x4000004f, %eax       # imm = 0x4000004F
je 0x30ac
jmp 0x3052
movl -0x84(%rbp), %eax
subl $0x40000050, %eax       # imm = 0x40000050
je 0x309d
jmp 0x3061
movl -0x84(%rbp), %eax
subl $0x40000051, %eax       # imm = 0x40000051
je 0x308e
jmp 0x3070
movl -0x84(%rbp), %eax
subl $0x40000052, %eax       # imm = 0x40000052
jne 0x30d7
jmp 0x307f
leaq -0x78(%rbp), %rdi
callq 0x36b0
movb $0x1, -0x42(%rbp)
jmp 0x30d7
leaq -0x78(%rbp), %rdi
callq 0x36d0
movb $0x1, -0x42(%rbp)
jmp 0x30d7
leaq -0x78(%rbp), %rdi
callq 0x3670
movb $0x1, -0x42(%rbp)
jmp 0x30d7
leaq -0x78(%rbp), %rdi
callq 0x3690
movb $0x1, -0x42(%rbp)
jmp 0x30d7
leaq -0x78(%rbp), %rdi
callq 0x3570
movb $0x1, -0x42(%rbp)
jmp 0x30d7
leaq -0x78(%rbp), %rdi
callq 0x35e0
movb $0x1, -0x42(%rbp)
jmp 0x30d9
jmp 0x30db
jmp 0x2ff1
testb $0x1, -0x42(%rbp)
je 0x30f3
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2ba0
jmp 0x2fdf
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bsaikiran618[P]mandelbrot-set-viewer/Cartesian2D.cpp
// Function: Cartesian2DPlane::Cartesian2DPlane(unsigned long, unsigned long, double)
Cartesian2DPlane::Cartesian2DPlane(uint64_t w, uint64_t h, double zoom)
{
	width = w;
	height = h;
	originX = width/2;
	originY = height/2;
	XScaleFactor = zoom;
	YScaleFactor = (height/double(width)) * XScaleFactor;
	// The above calculation makes sure that X and Y are
	// "stretched" to equal lengths, so that even if the
	// height and width are not same, we can have a grid
	// of squares.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
shrq %rcx
movq %rcx, 0x18(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movq 0x8(%rax), %xmm0
movaps 0xbfd(%rip), %xmm3      # 0x4120
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xc01(%rip), %xmm2      # 0x4130
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq (%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
mulsd 0x20(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bsaikiran618[P]mandelbrot-set-viewer/Mandelbrot.cpp
// Function: inMandelbrotSet(std::complex<double>, unsigned long)
int inMandelbrotSet(std::complex<double> point, uint64_t max_iters)
{
	std::complex<double> initial = point;
	int count = 0;
	for(uint64_t i=0;i<max_iters;i++)
	{
		if(std::abs(point) > 2) return count;
		point = std::pow(point, 2) + initial;
		count++;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3824
leaq -0x18(%rbp), %rdi
callq 0x3840
movsd 0x998(%rip), %xmm1      # 0x4158
ucomisd %xmm1, %xmm0
jbe 0x37ce
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x382b
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x38c0
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3880
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x37a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: WorkQueue<MyWorkItem*>::add(MyWorkItem*)
void add(T item) {
    pthread_mutex_lock(&m_mutex);
    m_queue.push_back(item);
    pthread_cond_signal(&m_condv);
    pthread_mutex_unlock(&m_mutex);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3080
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x20a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: WorkThread::start()
int start()
  {
    int result = pthread_create(&m_tid, NULL, runThread, this);
    if (result == 0) {
      m_running = 1;
    }
    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x28a(%rip), %rdx       # 0x2b50
callq 0x21d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x28df
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: WorkThread::join()
int join()
  {
    int result = -1;
    if (m_running == 1) {
      result = pthread_join(m_tid, NULL);
      if (result == 0) {
	m_detached = 1;
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x29c8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x29c6
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x29c8
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: ConsumerThread<MyWorkItem, MyThreadItem>::run()
void* run() {
    // Remove 1 item at a time and process it. Blocks if no items are 
    // available to process.
    for (int i = 0;; i++) {
      W* item = (W*)m_queue.remove();
      if (!item)
	return NULL;
      item->run(m_thread_data); // pass thread data to worker unit always
      delete item;
      if (m_queue.size() == 0)
        return NULL;
    }
    return NULL;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x34b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x344d
movq $0x0, -0x8(%rbp)
jmp 0x34a3
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x3530
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x347a
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x2100
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3560
cmpl $0x0, %eax
jne 0x3496
movq $0x0, -0x8(%rbp)
jmp 0x34a3
jmp 0x3498
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x342b
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: WorkQueue<MyWorkItem*>::remove()
T remove() {
    pthread_mutex_lock(&m_mutex);
    while (m_queue.size() == 0) {
      pthread_cond_wait(&m_condv, &m_mutex);
    }
    T item = m_queue.front();
    m_queue.pop_front();
    pthread_mutex_unlock(&m_mutex);
    return item;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x35a0
cmpq $0x0, %rax
jne 0x34f2
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x18, %rsi
callq 0x2180
jmp 0x34cd
movq -0x18(%rbp), %rdi
callq 0x35d0
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x3600
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x20a0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: walaj[P]pthread-lite/./pthread-lite.h
// Function: WorkQueue<MyWorkItem*>::size()
int size() {
    pthread_mutex_lock(&m_mutex);
    int size = m_queue.size();
    pthread_mutex_unlock(&m_mutex);
    return size;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x35a0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x18, %rdi
callq 0x20a0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: walaj[P]pthread-lite/example.cpp
// Function: MyWorkItem::runStringProcessing(MyThreadItem*)
bool runStringProcessing(MyThreadItem* thread_data) {
      // do something with the data ... (silly example here)
      size_t results = 0;
      if (m_data) 
	for (size_t n = 0; n < 1000; ++n) 
	  for (size_t i = 0; i < m_len; ++i)
	    if (m_data[i] == 'a')
	      ++results;
      thread_data->AddHits(results);   // store the results in the thread-level store
      
      if (m_data) free(m_data);        // done with this unit, so clear data
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x3800
movq $0x0, -0x20(%rbp)
cmpq $0x3e8, -0x20(%rbp)     # imm = 0x3E8
jae 0x37fe
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x37ee
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jne 0x37de
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x37e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x37b0
jmp 0x37f0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x379e
jmp 0x3800
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3830
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3823
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2130
ud2
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Basket.cc
// Function: Basket::total_receipt(std::ostream&) const
double Basket::total_receipt(ostream &os) const
{
    double sum = 0.0;    // holds the running total 


    // iter refers to the first element in a batch of elements with the same ISBN
    // upper_bound returns an iterator to the element just past the end of that batch
    for (auto iter = items.cbegin(); 
              iter != items.cend();
              iter = items.upper_bound(*iter)) {
        // we know there's at least one element with this key in the Basket
		// print the line item for this book
        sum += print_total(os, **iter, items.count(*iter));  
    } 
	os << "Total Sale: " << sum << endl; // print the final overall total
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x6270
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x62a0
testb $0x1, %al
jne 0x6199
jmp 0x620b
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6300
movq %rax, %rdi
callq 0x63c0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6300
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6360
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x6a00
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6300
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6390
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6179
movq -0x10(%rbp), %rdi
leaq 0xfc7(%rip), %rsi       # 0x71dd
callq 0x20d0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x21a0
movq %rax, %rdi
movq 0x5d8e(%rip), %rsi      # 0xbfc0
callq 0x2100
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc
// Function: print_total(std::ostream&, Quote const&, unsigned long)
double print_total(ostream &os, 
                   const Quote &item, size_t n)
{
	// depending on the type of the object bound to the item parameter
	// calls either Quote::net_price or Bulk_quote::net_price
	double ret = item.net_price(n); 
    os << "ISBN: " << item.isbn() // calls Quote::isbn
       << " # sold: " << n << " total due: " << ret << endl;
 	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7c0(%rip), %rsi       # 0x71f8
callq 0x20d0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6330
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x20c0
movq %rax, -0x58(%rbp)
jmp 0x6a65
movq -0x58(%rbp), %rdi
leaq 0x78f(%rip), %rsi       # 0x71ff
callq 0x20d0
movq %rax, -0x70(%rbp)
jmp 0x6a7b
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2030
movq %rax, -0x78(%rbp)
jmp 0x6a8e
movq -0x78(%rbp), %rdi
leaq 0x770(%rip), %rsi       # 0x7209
callq 0x20d0
movq %rax, -0x80(%rbp)
jmp 0x6aa4
movq -0x80(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x21a0
movq %rax, -0x88(%rbp)
jmp 0x6abb
movq -0x88(%rbp), %rdi
movq 0x54f7(%rip), %rsi      # 0xbfc0
callq 0x2100
jmp 0x6ad0
leaq -0x40(%rbp), %rdi
callq 0x2090
movsd -0x20(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2090
movq -0x48(%rbp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc
// Function: Lim_quote::net_price(unsigned long) const
double Lim_quote::net_price(size_t cnt) const
{
    size_t discounted = min(cnt, quantity);
    size_t undiscounted = cnt - discounted;
    return discounted * (1 - discount) * price 
           + undiscounted * price;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x30, %rsi
leaq -0x10(%rbp), %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movaps 0x417(%rip), %xmm4      # 0x7020
movq -0x18(%rbp), %xmm0
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x416(%rip), %xmm3      # 0x7030
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x28(%rax), %xmm2
movsd 0x38(%rax), %xmm5
movsd 0x5b5(%rip), %xmm1      # 0x71f0
subsd %xmm5, %xmm1
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
mulsd 0x28(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yangwanyuan[P]HLKVDS/tools/DbTest.cc
// Function: Create_DB_Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Create_DB_Test(string filename) {

    int record_num = 10;
    int ht_size = record_num * 2;

    Options opts;
    opts.segment_size = 256 * 1024;
    opts.hashtable_size = ht_size;

    KVDS *db = KVDS::Create_KVDS(filename.c_str(), opts);

    delete db;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x58(%rsp)
movq %rdi, 0x120(%rsp)
movl $0xa, 0x11c(%rsp)
movl 0x11c(%rsp), %eax
shll %eax
movl %eax, 0x118(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x37460
movq 0x58(%rsp), %rdi
movl $0x40000, 0x10c(%rsp) # imm = 0x40000
movl 0x118(%rsp), %eax
movl %eax, 0x108(%rsp)
callq 0x8180
movq %rax, 0x60(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
movl $0x50, %edx
callq 0x8410
movq 0x60(%rsp), %rdi
movups 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2b5c0
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, %rax
je 0x8e06
movq 0x68(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x128, %rsp            # imm = 0x128
retq
nop
// File: yangwanyuan[P]HLKVDS/tools/DbTest.cc
// Function: main
int main(int argc, char** argv) {
    string filename = argv[1];

    Create_DB_Test(filename);
    Open_DB_Test(filename);
    std::cout << "first process success" << std::endl;
    Create_DB_Test(filename);
    Open_DB_Test(filename);
    return 0;
}

// Assembly:
subq $0xe8, %rsp
movl $0x0, 0xe4(%rsp)
movl %edi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0xb7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8830
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x8680
jmp 0x9f3d
leaq 0xb7(%rsp), %rdi
callq 0x8540
leaq 0x80(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x81a0
jmp 0x9f61
leaq 0x80(%rsp), %rdi
callq 0x8d20
jmp 0x9f70
leaq 0x80(%rsp), %rdi
callq 0x8928
leaq 0x60(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x81a0
jmp 0x9f91
leaq 0x60(%rsp), %rdi
callq 0x8e10
jmp 0x9f9d
leaq 0x60(%rsp), %rdi
callq 0x8928
movq 0x67022(%rip), %rdi     # 0x70fd0
leaq 0x481f0(%rip), %rsi     # 0x521a5
callq 0x84e0
movq %rax, 0x8(%rsp)
jmp 0x9fc1
movq 0x8(%rsp), %rdi
movq 0x66fd3(%rip), %rsi     # 0x70fa0
callq 0x8520
jmp 0x9fd4
leaq 0x40(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x81a0
jmp 0x9fe8
leaq 0x40(%rsp), %rdi
callq 0x8d20
jmp 0x9ff4
leaq 0x40(%rsp), %rdi
callq 0x8928
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x81a0
jmp 0xa012
leaq 0x20(%rsp), %rdi
callq 0x8e10
jmp 0xa01e
leaq 0x20(%rsp), %rdi
callq 0x8928
movl $0x0, 0xe4(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x8928
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb7(%rsp), %rdi
callq 0x8540
jmp 0xa11c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0xa10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x8928
jmp 0xa10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8928
jmp 0xa10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8928
jmp 0xa10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8928
leaq 0xb8(%rsp), %rdi
callq 0x8928
movq 0xa8(%rsp), %rdi
callq 0x8820
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/rmd160.c
// Function: MDinit
void MDinit(dword *MDbuf) {
    MDbuf[0] = 0x67452301UL;
    MDbuf[1] = 0xefcdab89UL;
    MDbuf[2] = 0x98badcfeUL;
    MDbuf[3] = 0x10325476UL;
    MDbuf[4] = 0xc3d2e1f0UL;

    return;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rsp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rsp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rsp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rsp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/rmd160.c
// Function: MDfinish
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen) {
    dword i; /* counter       */
    dword X[16]; /* message words */

    memset(X, 0, 16 * sizeof(dword));

    /* put bytes from strptr into X */
    for (i = 0; i < (lswlen & 63); i++) {
        /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
        X[i >> 2] ^= (dword) *strptr++ << (8 * (i & 3));
    }

    /* append the bit m_n == 1 */
    X[(lswlen >> 2) & 15] ^= (dword) 1 << (8 * (lswlen & 3) + 7);

    if ((lswlen & 63) > 55) {
        /* length goes to next block */
        compress_(MDbuf, X);
        memset(X, 0, 16 * sizeof(dword));
    }

    /* append length in bits*/
    X[14] = lswlen << 3;
    X[15] = (lswlen >> 29) | (mswlen << 3);
    compress_(MDbuf, X);

    return;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x8280
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl 0x54(%rsp), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jae 0x105ea
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rsp)
movzbl (%rax), %eax
movl 0x4c(%rsp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shll %cl, %eax
movl %eax, %ecx
movl 0x4c(%rsp), %eax
shrl $0x2, %eax
movl %eax, %eax
xorl (%rsp,%rax,4), %ecx
movl %ecx, (%rsp,%rax,4)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1059d
movl 0x54(%rsp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
addl $0x7, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movl 0x54(%rsp), %eax
shrl $0x2, %eax
andl $0xf, %eax
movl %eax, %eax
xorl (%rsp,%rax,4), %ecx
movl %ecx, (%rsp,%rax,4)
movl 0x54(%rsp), %eax
andl $0x3f, %eax
cmpl $0x37, %eax
jbe 0x1063a
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0xcbb0
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x8280
movl 0x54(%rsp), %eax
shll $0x3, %eax
movl %eax, 0x38(%rsp)
movl 0x54(%rsp), %eax
shrl $0x1d, %eax
movl 0x50(%rsp), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, 0x3c(%rsp)
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0xcbb0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::ReadData(hlkvds::KVSlice&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Status DS_MultiTier_Impl::ReadData(KVSlice &slice, std::string &data) {
    HashEntry *entry;
    entry = &slice.GetHashEntry();

    TierType tier_type = locateTierFromEntry(entry);
    if (tier_type == TierType::FastTierType) {
        return ft_->ReadData(slice, data);
    }
    return mt_->ReadData(slice, data);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x116b0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10c30
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x10c05
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x4b230
jmp 0x10c21
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x4ce40
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::locateTierFromEntry(hlkvds::HashEntry*)
DS_MultiTier_Impl::TierType DS_MultiTier_Impl::locateTierFromEntry(HashEntry *entry) {
    uint16_t pos = entry->GetHeaderLocation();
    int vol_id = (int)pos;
    if (vol_id == hlkvds::FastTierVolId) {
        return TierType::FastTierType;
    }
    return TierType::MediumTierType;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11790
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x64, 0x8(%rsp)
jne 0x10c67
movl $0x0, 0x24(%rsp)
jmp 0x10c6f
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::GetSBReservedContent(char*, unsigned long)
bool DS_MultiTier_Impl::GetSBReservedContent(char* buf, uint64_t length) {
    if (length != SuperBlockManager::ReservedRegionLength()) {
        return false;
    }
    memset((void*)buf, 0, length);

    char* buf_ptr = buf;
    //Get sbResHeader_
    uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
    memcpy((void*)buf_ptr, (const void*)&sbResHeader_, header_size);
    buf_ptr += header_size;
    __DEBUG("SB_RESERVED_HEADER: sb_reserved_fast_tier_size = %d, sb_reserved_medium_tier_size = %d ",
            sbResHeader_.sb_reserved_fast_tier_size, sbResHeader_.sb_reserved_medium_tier_size);

    //Get FastTier
    if (!ft_->GetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_fast_tier_size)) {
        return false;
    }
    buf_ptr += sbResHeader_.sb_reserved_fast_tier_size;

    //Get MediumTier
    if (!mt_->GetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_medium_tier_size)) {
        return false;
    }

    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x10cf3
movb $0x0, 0x47(%rsp)
jmp 0x10d9b
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x8, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x28, %rsi
movq 0x18(%rsp), %rdx
callq 0x8410
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x28(%rax), %eax
movl %eax, %edx
callq 0x4b410
testb $0x1, %al
jne 0x10d61
movb $0x0, 0x47(%rsp)
jmp 0x10d9b
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movq 0x20(%rsp), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rax), %eax
movl %eax, %edx
callq 0x4d0f0
testb $0x1, %al
jne 0x10d96
movb $0x0, 0x47(%rsp)
jmp 0x10d9b
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc
// Function: hlkvds::DS_MultiTier_Impl::SetSBReservedContent(char*, unsigned long)
bool DS_MultiTier_Impl::SetSBReservedContent(char* buf, uint64_t length) {
    if (length != SuperBlockManager::ReservedRegionLength()) {
        return false;
    }

    char* buf_ptr = buf;
    //Set sbResHeader_
    uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
    memcpy((void*)&sbResHeader_, (const void*)buf_ptr, header_size);
    buf_ptr += header_size;
    __DEBUG("SB_RESERVED_HEADER: sb_reserved_fast_tier_size = %d, sb_reserved_medium_tier_size = %d ",
            sbResHeader_.sb_reserved_fast_tier_size, sbResHeader_.sb_reserved_medium_tier_size);

    //Set FastTier
    if (!ft_->SetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_fast_tier_size)) {
        return false;
    }
    buf_ptr += sbResHeader_.sb_reserved_fast_tier_size;

    //Set MediumTier
    if (!mt_->SetSBReservedContent(buf_ptr, sbResHeader_.sb_reserved_medium_tier_size)) {
        return false;
    }

    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x10df3
movb $0x0, 0x47(%rsp)
jmp 0x10e8a
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x8, 0x18(%rsp)
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8410
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x28(%rax), %eax
movl %eax, %edx
callq 0x4b480
testb $0x1, %al
jne 0x10e50
movb $0x0, 0x47(%rsp)
jmp 0x10e8a
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movq 0x20(%rsp), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rax), %eax
movl %eax, %edx
callq 0x4d290
testb $0x1, %al
jne 0x10e85
movb $0x0, 0x47(%rsp)
jmp 0x10e8a
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)