LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/renderer.cpp
// Function: renderer::calculateRayDirection(double, double)
math::vec3 renderer::calculateRayDirection(double xcoord, double ycoord) {
	//
	// find direction vector
	//
	double x = xcoord - WIDTH / 2.0;
	double y = ycoord - HEIGHT / 2.0;
	double z = HEIGHT / std::tan(FOV * PI / 180.0 / 2.0);
	math::vec3 a = math::vec3(x, y, -z);
	//
	// apply rotations
	//
	a = math::vec3(
		RMx[0].x * a.x + RMx[1].x * a.y + RMx[2].x * a.z,
		RMx[0].y * a.x + RMx[1].y * a.y + RMx[2].y * a.z,
		RMx[0].z * a.x + RMx[1].z * a.y + RMx[2].z * a.z
	);
	a = math::vec3(
		RMy[0].x * a.x + RMy[1].x * a.y + RMy[2].x * a.z,
		RMy[0].y * a.x + RMy[1].y * a.y + RMy[2].y * a.z,
		RMy[0].z * a.x + RMy[1].z * a.y + RMy[2].z * a.z);

	return math::normalize(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
cvtsi2sdl (%rsi), %xmm2
movq %rdi, %rbx
movsd 0x73e9(%rip), %xmm3     # 0xe008
mulsd %xmm3, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm2, %xmm2
cvtsi2sdl 0x4(%rsi), %xmm2
movapd %xmm2, -0x40(%rbp)
mulsd %xmm3, %xmm2
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rsi), %xmm0
mulsd 0x7c33(%rip), %xmm0     # 0xe880
subsd %xmm2, %xmm1
movsd %xmm1, -0x28(%rbp)
divsd 0x7c2a(%rip), %xmm0     # 0xe888
mulsd %xmm3, %xmm0
callq 0x3170
movapd -0x40(%rbp), %xmm2
xorpd 0x7bdc(%rip), %xmm2     # 0xe850
divsd %xmm0, %xmm2
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x61f4
movq 0x90(%r15), %rax
movsd (%r14), %xmm3
movsd 0x8(%r14), %xmm4
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm2
movsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x28(%rax), %xmm4
mulsd 0x10(%rax), %xmm3
addsd %xmm4, %xmm3
mulsd 0x40(%rax), %xmm2
addsd %xmm3, %xmm2
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x61f4
movq %r14, %rdi
movq %r12, %rsi
callq 0x6338
movq 0xa8(%r15), %rax
movsd (%r14), %xmm3
movsd 0x8(%r14), %xmm4
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm2
movsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x28(%rax), %xmm4
mulsd 0x10(%rax), %xmm3
addsd %xmm4, %xmm3
mulsd 0x40(%rax), %xmm2
addsd %xmm3, %xmm2
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x61f4
movq %r14, %rdi
movq %r15, %rsi
callq 0x6338
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6590
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/renderer.cpp
// Function: renderer::march(math::ray)
double renderer::march(math::ray r) {
	double t = MIN_DIST;
	for (; t < MAX_DIST; ) {
		double h = f->de(r.origin + r.direction * t);
		if (h < MIN_DIST) {
			break;
		}
		t += h;
	}
	if (t < MAX_DIST) return t;
	return -1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movsd 0x7180(%rip), %xmm0     # 0xe8a0
leaq 0x28(%rbp), %r15
leaq -0x60(%rbp), %r12
leaq -0x48(%rbp), %r13
movapd %xmm0, %xmm1
movsd 0x7170(%rip), %xmm0     # 0xe8a8
ucomisd %xmm1, %xmm0
jbe 0x779c
movq 0xc0(%rbx), %r14
movq %r12, %rdi
movq %r15, %rsi
movapd %xmm1, %xmm0
movsd %xmm1, -0x30(%rbp)
callq 0x62a4
movq %r13, %rdi
leaq 0x10(%rbp), %rsi
movq %r12, %rdx
callq 0x6208
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x48(%rbp), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x8b6e
movsd 0x7115(%rip), %xmm1     # 0xe8a0
ucomisd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm0
jbe 0x772c
jmp 0x77a4
movsd 0x7094(%rip), %xmm1     # 0xe838
movapd %xmm1, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/renderer.cpp
// Function: renderer::brdf(math::vec3, math::vec3)
math::vec3 renderer::brdf(math::vec3 direction, math::vec3 normal) {
	if (s->d(0.0, 1.0) > GLOSSINESS_CHANCE) {
		//
		// diffuse reflection without tangent thanks to Edd 
		// Biddulph:
		// http://www.amietia.com/lambertnotangent.html
		//
		double a = s->d(0.0, 1.0);
		double b = s->d(0.0, 1.0);
		// not an arbitrary number, it's pi * 2
		double theta = 6.283185 * a;
		b = 2.0 * b - 1.0;
		double bsqrt = std::sqrt(1.0 - b * b);
		math::vec3 point(bsqrt * cos(theta), bsqrt * sin(theta), b);
		return math::normalize(normal + point);
	} else {
		//
		// glossy reflection
		//
		math::vec3 reflection = math::reflect(direction, normal);
		double a = PI;
		double b = 2 * PI;
		math::vec3 uniformVector(std::sin(b) * std::sin(a), std::cos(b) * std::sin(a), std::cos(a));
		return math::normalize(reflection + uniformVector) * GLOSSINESS_AMOUNT;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rbp), %r14
movq 0xc8(%rsi), %rdi
movsd 0x6e93(%rip), %xmm1     # 0xe678
xorpd %xmm0, %xmm0
callq 0xa334
ucomisd 0x20(%r15), %xmm0
jbe 0x787d
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x6e6b(%rip), %xmm1     # 0xe678
callq 0xa334
movsd %xmm0, -0x30(%rbp)
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x6e4e(%rip), %xmm1     # 0xe678
callq 0xa334
movsd -0x30(%rbp), %xmm1
mulsd 0x7084(%rip), %xmm1     # 0xe8c0
movsd %xmm1, -0x30(%rbp)
addsd %xmm0, %xmm0
addsd 0x6feb(%rip), %xmm0     # 0xe838
movsd %xmm0, -0x48(%rbp)
mulsd %xmm0, %xmm0
movsd 0x6e1a(%rip), %xmm1     # 0xe678
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
ucomisd 0x705a(%rip), %xmm1     # 0xe8c8
jb 0x791c
sqrtsd %xmm0, %xmm0
jmp 0x7921
leaq 0x10(%rbp), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x6719
leaq -0xa8(%rbp), %r12
movsd 0x6ff2(%rip), %xmm0     # 0xe8b0
movsd 0x6ff2(%rip), %xmm1     # 0xe8b8
movsd 0x6f6a(%rip), %xmm2     # 0xe838
movq %r12, %rdi
callq 0x61f4
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6208
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x6590
movsd 0x28(%r15), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62a4
jmp 0x7993
callq 0x3220
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x34e0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3080
movsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
callq 0x61f4
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6208
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6590
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/fractal.cpp
// Function: fractal::calculateShadow(math::ray)
double fractal::calculateShadow(math::ray r) {
	double res = 1.0;
	double ph = 1e20;
	double tmax = 16.0;
	double t = 0.0001;

	//
	// kinda like raymarching the shadow with some fancy modifiers
	// to make it soft and round
	//
	for(; t < tmax; ) {
		double h = de(r.origin + r.direction * t);
		if (h < 0.001) {
			return 0.0;
		}
		double y = h * h / (2.0 * ph);
		double d = std::sqrt(h * h - y * y);
		res = std::min(res, shadowSoftness * d / std::max(0.0, t - y));
		ph = h;
		t += h;
	}

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsd 0x5a93(%rip), %xmm1     # 0xe678
movsd 0x5dfb(%rip), %xmm2     # 0xe9e8
movsd 0x5dfb(%rip), %xmm4     # 0xe9f0
leaq -0x90(%rbp), %r12
leaq -0x78(%rbp), %r13
leaq -0x60(%rbp), %r14
movsd %xmm4, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movq %r12, %rdi
leaq 0x28(%rbp), %rsi
movsd %xmm2, -0x40(%rbp)
movapd %xmm2, %xmm0
callq 0x62a4
movq %r13, %rdi
leaq 0x10(%rbp), %rsi
movq %r12, %rdx
callq 0x6208
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movupd -0x78(%rbp), %xmm0
movapd %xmm0, -0x60(%rbp)
cmpl $0x0, (%rbx)
jle 0x8c60
xorl %r15d, %r15d
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
incl %r15d
cmpl (%rbx), %r15d
jl 0x8c4c
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x60(%rbp), %xmm0
movups %xmm0, (%rsp)
movsd 0x59ff(%rip), %xmm0     # 0xe678
callq 0x6930
movapd %xmm0, %xmm4
movsd 0x5d6e(%rip), %xmm0     # 0xe9f8
ucomisd %xmm4, %xmm0
ja 0x8d25
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm0, %xmm5
divsd %xmm1, %xmm5
movapd %xmm5, %xmm1
mulsd %xmm5, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x5c07(%rip), %xmm0     # 0xe8c8
jb 0x8cc9
sqrtsd %xmm0, %xmm0
jmp 0x8ce2
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x48(%rbp)
callq 0x3220
movsd -0x48(%rbp), %xmm5
movsd -0x30(%rbp), %xmm4
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
mulsd 0x48(%rbx), %xmm0
movapd %xmm2, %xmm1
subsd %xmm5, %xmm1
maxsd 0x5bc7(%rip), %xmm1     # 0xe8c8
divsd %xmm1, %xmm0
minsd %xmm3, %xmm0
addsd %xmm4, %xmm2
movsd 0x5ceb(%rip), %xmm1     # 0xea00
ucomisd %xmm2, %xmm1
movapd %xmm0, %xmm1
ja 0x8c04
jmp 0x8d29
xorpd %xmm0, %xmm0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/fractal.cpp
// Function: PI0::iterate(math::vec3&)
inline void iterate(math::vec3& point) {
		point = math::absolute(point);
		math::rotation::x(point, xrs, xrc);
		math::rotation::z(point, zrs, zrc);
		math::fold::menger(point);
		math::rotation::z(point, zrs, zrc);
		math::rotation::x(point, xrs, xrc);
		math::fold::sierpinski(point);
		point.x += xs;
		point.z += zs;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movups (%rsi), %xmm0
movups %xmm0, (%rsp)
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x65e6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6338
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x6866
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x68c8
movq %rbx, %rdi
callq 0x67fc
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x68c8
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x6866
movq %rbx, %rdi
callq 0x6792
movsd 0x8(%r14), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::crc32(unsigned char const*, unsigned long)
void TinyPngOut::crc32(const uint8_t data[], size_t len) {
	crc = ~crc;
	for (size_t i = 0; i < len; i++) {
		for (int j = 0; j < 8; j++) {  // Inefficient bitwise implementation, instead of table-based
			uint32_t bit = (crc ^ (data[i] >> j)) & 1;
			crc = (crc >> 1) ^ ((-bit) & UINT32_C(0xEDB88320));
		}
	}
	crc = ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %ecx
movl %ecx, %eax
notl %eax
movl %eax, 0x28(%rdi)
testq %rdx, %rdx
je 0xd03f
xorl %r8d, %r8d
xorl %ecx, %ecx
movzbl (%rsi,%r8), %r9d
shrl %cl, %r9d
xorl %eax, %r9d
andl $0x1, %r9d
negl %r9d
movl %eax, %r10d
shrl %r10d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
movl %r9d, %eax
xorl %r10d, %eax
movl %eax, 0x28(%rdi)
incl %ecx
cmpl $0x8, %ecx
jne 0xd004
incq %r8
cmpq %rdx, %r8
jne 0xd002
notl %eax
movl %eax, %ecx
movl %ecx, 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::adler32(unsigned char const*, unsigned long)
void TinyPngOut::adler32(const uint8_t data[], size_t len) {
	uint32_t s1 = adler & 0xFFFF;
	uint32_t s2 = adler >> 16;
	for (size_t i = 0; i < len; i++) {
		s1 = (s1 + data[i]) % 65521;
		s2 = (s2 + s1) % 65521;
	}
	adler = s2 << 16 | s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2c(%rdi), %eax
movzwl %ax, %r10d
shrl $0x10, %eax
testq %rdx, %rdx
je 0xd447
xorl %ecx, %ecx
movl $0x80078071, %r9d       # imm = 0x80078071
movzbl (%rsi,%rcx), %r8d
addl %r10d, %r8d
movq %r8, %r10
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %r8d
addl %r8d, %eax
movq %rax, %r10
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %eax
incq %rcx
movl %r8d, %r10d
cmpq %rcx, %rdx
jne 0xd405
jmp 0xd44a
movl %r10d, %r8d
shll $0x10, %eax
orl %r8d, %eax
movl %eax, 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::ThreadPool(MyConf&, int)
ThreadPool(MyConf &conf, int size = 12)
            :vecThreads_(size),
             queueTaskslock_(), 
             queueTasksCond_(queueTaskslock_),
             isStarted_(false),
             conf_(conf),
             cacheThread_(size)
        {
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); 
                iter != vecThreads_.end(); 
                ++iter)
            {
                iter -> get_related(this);       // 使线程池中的每一个工作线程持有线程池对象的指针
            }
                cacheThread_.get_related(this);      // 使线程池中的扫描线程持有线程池对象的指针
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl %edx, -0x3c(%rbp)
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movslq %edx, %rsi
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x591a
leaq 0x20(%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x5f10
leaq 0x70(%r15), %r12
movq %r12, %rdi
callq 0x59a8
leaq 0x98(%r15), %rdi
movq %r12, %rsi
callq 0x5a56
movb $0x0, 0xd0(%r15)
leaq 0xd8(%r15), %r13
leaq -0x3c(%rbp), %rsi
movq %r13, %rdi
callq 0x5b0c
movq 0x8(%r15), %rax
cmpq 0x10(%r15), %rax
je 0x423b
movq %r15, 0x58(%rax)
addq $0xc0, %rax
jmp 0x4229
movq %r13, %rdi
movq %r15, %rsi
callq 0x88b6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x38(%rbp)
movq %r13, %rdi
callq 0x5b6a
jmp 0x4267
movq %rax, -0x38(%rbp)
addq $0xa0, %r15
movq %r15, %rdi
callq 0x3510
jmp 0x427c
movq %rax, -0x38(%rbp)
movq %r12, %rdi
callq 0x3330
jmp 0x428a
movq %rax, -0x38(%rbp)
movq %r14, %rdi
callq 0x6144
jmp 0x4298
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
callq 0x5bac
movq -0x38(%rbp), %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::on()
void on()
        {
            if(isStarted_)
            {
                return ;
            }
            isStarted_ = true ;
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); iter != vecThreads_.end(); iter ++)
            {
                iter -> start();    // 开启工作线程
            }
            cacheThread_.start();   // 开启扫描线程
        }

// Assembly:
cmpb $0x0, 0xd0(%rdi)
je 0x456c
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0xd0(%rdi)
movq 0x8(%rdi), %r14
cmpq 0x10(%rbx), %r14
je 0x459a
movq %r14, %rdi
xorl %esi, %esi
callq 0x629c
addq $0xc0, %r14
jmp 0x4581
addq $0xd8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x629c
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::allocate_task(MyTask&)
void allocate_task( MyTask& task)
        {
            queueTaskslock_.lock();
            std::cout << "Add Task" << std::endl ;
            queueTasks_.push(task);
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x33f0
movq 0x8982(%rip), %r12      # 0xcfd0
leaq 0x4b78(%rip), %rsi      # 0x91cd
movl $0x8, %edx
movq %r12, %rdi
callq 0x3310
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x640e
movq %r14, %rdi
callq 0x3220
addq $0xa0, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/MyLock.h
// Function: MyLock::MyLock()
MyLock()
        {
            // 初始化成功返回0
            if( pthread_mutex_init(&m_mutex, NULL) )
            {
                std::cout << __DATE__  << " " << __TIME__ << " " 
                          << __FILE__  << " " << __LINE__ << ":"
                          << "pthread_mutex_init failed!" << std::endl;
                exit (-1); 
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %esi, %esi
callq 0x3410
testl %eax, %eax
jne 0x59c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x7609(%rip), %rdi      # 0xcfd0
leaq 0x365d(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x388b(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x364b(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x36fc(%rip), %rsi      # 0x9102
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
movl $0xe, %esi
callq 0x34a0
leaq 0x3856(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x36d9(%rip), %rsi      # 0x9115
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
callq 0x3150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/MyCondition.h
// Function: MyCondition::MyCondition(MyLock&)
MyCondition(MyLock& lock)
            : m_mutex(lock.m_mutex)
        {
            if( pthread_cond_init(&m_cond, NULL))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ": " 
                          << "pthread_cond_init failed!" << std::endl;
                exit (-1);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, (%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x3340
testl %eax, %eax
jne 0x5a75
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x7554(%rip), %rdi      # 0xcfd0
leaq 0x35a8(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x37d6(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3596(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3675(%rip), %rsi      # 0x9130
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
movl $0xe, %esi
callq 0x34a0
leaq 0x3782(%rip), %rsi      # 0x9264
movq %rax, %rdi
callq 0x32a0
leaq 0x3657(%rip), %rsi      # 0x9148
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
callq 0x3150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::Thread()
Thread()
            :threadId_(0),isRunning_(false)
        {
            if(pthread_attr_init(&threadAttr))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_init" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7007(%rip), %rax      # 0xcd20
movq %rax, (%rdi)
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x3360
testl %eax, %eax
jne 0x5d3c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x728d(%rip), %rdi      # 0xcfd0
leaq 0x32e1(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x350f(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x32cf(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x335b(%rip), %rsi      # 0x90dd
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
movl $0xf, %esi
callq 0x34a0
leaq 0x34da(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x3338(%rip), %rsi      # 0x90f0
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
callq 0x3150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::start(void*)
void start(void* arg = NULL)
        {
            if(isRunning_)
                return;
			
            m_arg = arg ;
            isRunning_ = true ;
            
            // 将线程设置为detach
            if(pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_setdetachstate" << std::endl ;
                exit(-1) ;
            }
            
            // 创建线程
            if(pthread_create(&threadId_, &threadAttr, Thread::runInThread, this))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_create" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x0, 0x10(%rdi)
jne 0x62e7
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x33a0
testl %eax, %eax
jne 0x62ec
leaq 0x18(%rbx), %rdi
leaq 0x12c(%rip), %rdx       # 0x6400
movq %r14, %rsi
movq %rbx, %rcx
callq 0x34d0
testl %eax, %eax
jne 0x636a
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6cdd(%rip), %rdi      # 0xcfd0
leaq 0x2d31(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x2f5f(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2d1f(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2dab(%rip), %rsi      # 0x90dd
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
movl $0x26, %esi
callq 0x34a0
leaq 0x2f2a(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x2e29(%rip), %rsi      # 0x9191
jmp 0x63e6
movq 0x6c5f(%rip), %rdi      # 0xcfd0
leaq 0x2cb3(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x2ee1(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2ca1(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2d2d(%rip), %rsi      # 0x90dd
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
movl $0x2f, %esi
callq 0x34a0
leaq 0x2eac(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x2dc7(%rip), %rsi      # 0x91ad
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
callq 0x3150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./src/MyThread.cpp
// Function: MyThread::run()
void MyThread::run()
{
	std::cout << "run" << std::endl ;
	cache_.read_from_file( (threadPoolPtr_ -> conf_).getMapConf()["my_cache"].c_str());
	while(true)
	{
        MyTask task(threadPoolPtr_-> conf_) ;
        if(!(threadPoolPtr_ -> get_task(task)) )
        {
            break ;
        }
        task.excute(cache_) ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x66ca(%rip), %r14      # 0xcfd0
leaq 0x2902(%rip), %rsi      # 0x920f
movl $0x3, %edx
movq %r14, %rdi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x58(%rbx), %rax
movq (%rax), %r14
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28bc(%rip), %rsi      # 0x9213
leaq 0x28bd(%rip), %rdx      # 0x921b
leaq -0x50(%rbp), %rdi
callq 0x4984
addq $0x208, %r14            # imm = 0x208
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x4728
movq (%rax), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x3120
leaq 0x60(%rbx), %r14
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x6aa4
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69b5
callq 0x3280
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x69c3
callq 0x3280
leaq -0x70(%rbp), %r13
xorl %r12d, %r12d
leaq -0xb8(%rbp), %r15
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
leaq -0xa8(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq %r12, -0xb0(%rbp)
movb $0x0, -0xa8(%rbp)
leaq 0x238(%rax), %rcx
movq %rcx, -0x80(%rbp)
addq $0x250, %rax            # imm = 0x250
movq %rax, -0x78(%rbp)
movq %r12, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, -0x28(%r13)
movq %r15, %rsi
callq 0x6ca0
testb %al, %al
je 0x6a3b
movq %r15, %rdi
movq %r14, %rsi
callq 0x7518
movq %r15, %rdi
callq 0x46b6
jmp 0x69d1
leaq -0xb8(%rbp), %rdi
callq 0x46b6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a78
callq 0x3280
jmp 0x6a78
jmp 0x6a75
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x6a9c
callq 0x3280
jmp 0x6a9c
movq %rax, %rbx
jmp 0x6a9c
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x46b6
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/MyCache.h
// Function: MyCache::read_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void read_from_file(const std::string &fileName)
        {
            std::ifstream infile(fileName.c_str());
            if(!infile)
            {
                std::cout << "cache file: " << fileName << std::endl ; 
                throw std::runtime_error("open cache file fail !");
            }
            std::string query , result;
            while(infile >> query >> result)
            {
                hashmap_.insert(std::make_pair(query, result));
            }
            infile.close();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x2b0(%rbp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x34e0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x290(%rbp,%rax)
jne 0x6bd8
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x2b0(%rbp), %r14
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r12
leaq -0xa8(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3380
movq %rax, %rdi
movq %r12, %rsi
callq 0x3380
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6b8a
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4c82
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6dbc
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x6b70
callq 0x3280
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x6b1e
callq 0x3280
jmp 0x6b1e
leaq -0x2b0(%rbp), %rdi
callq 0x30a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6ba8
callq 0x3280
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x6bba
callq 0x3280
leaq -0x2b0(%rbp), %rdi
callq 0x30c0
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x63f1(%rip), %rdi      # 0xcfd0
leaq 0x2636(%rip), %rsi      # 0x921c
movl $0xc, %edx
callq 0x3310
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x63d2(%rip), %rdi      # 0xcfd0
callq 0x3310
movq %rax, %rdi
callq 0x3150
movl $0x10, %edi
callq 0x3160
movq %rax, %r14
leaq 0x260a(%rip), %rsi      # 0x9229
movq %rax, %rdi
callq 0x3110
movq 0x63c2(%rip), %rsi      # 0xcff0
movq 0x6393(%rip), %rdx      # 0xcfc8
movq %r14, %rdi
callq 0x3490
movq %rax, %rbx
movq %r14, %rdi
callq 0x3200
jmp 0x6c8b
movq %rax, %rbx
jmp 0x6c8b
jmp 0x6c64
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x46f2
jmp 0x6c67
jmp 0x6c64
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6c79
callq 0x3280
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x6c8b
callq 0x3280
leaq -0x2b0(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::get_task(MyTask&)
bool get_task(MyTask &task)
        {
            queueTaskslock_.lock();
            while(isStarted_ && queueTasks_.empty())
            {
                queueTasksCond_.wait();
            }
            if(!isStarted_)
            { 
                queueTaskslock_.unlock();
                queueTasksCond_.broadcast();
                return false ;
            }
            task = queueTasks_.front();
            queueTasks_.pop();
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
            std::cout << "get task" << std::endl ;
            return true ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x33f0
cmpb $0x1, 0xd0(%rbx)
jne 0x6cf2
leaq 0xa0(%rbx), %r15
movq 0x30(%rbx), %r13
cmpq %r13, 0x50(%rbx)
jne 0x6d10
movq 0x98(%rbx), %rsi
movq %r15, %rdi
callq 0x3420
cmpb $0x0, 0xd0(%rbx)
jne 0x6cd0
movq %r14, %rdi
callq 0x3220
addq $0xa0, %rbx
movq %rbx, %rdi
callq 0x30f0
xorl %eax, %eax
jmp 0x6dad
addq $0x20, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3180
movq 0x40(%r13), %rax
movq %rax, 0x40(%r12)
movups 0x20(%r13), %xmm0
movups 0x30(%r13), %xmm1
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x20(%r12)
addq $0x48, %r12
addq $0x48, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x71aa
movq %rbx, %rdi
callq 0x7496
movq %r14, %rdi
callq 0x3220
movq %r15, %rdi
callq 0x30f0
movq 0x6260(%rip), %rbx      # 0xcfd0
leaq 0x24c9(%rip), %rsi      # 0x9240
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::get_result()
void MyTask::get_result()
{
	std::string ch ;
	int index ;
	for(index = 0 ; index != queryWord_.size(); index ++ )
	{
		if(queryWord_[index] & (1 << 7))
		{
			ch = queryWord_.substr(index, 2) ;
			index ++ ;
		}else 
		{
			ch = queryWord_.substr(index, 1);
		}
		if( ( *mapIndexPtr_ ).count(ch) )
		{
			std::cout << "map_ cout return true " << std::endl ;
			satistic( (*mapIndexPtr_)[ch] ) ;
		}
	} 

	/*
	   std::cout <<__FILE__<<std::endl ;
	//	for_each((*m_dict).begin(), (*m_dict).end(), satistic );
	std::map<std::string , int>::iterator iter = (*m_dict).begin() ;
	//int line = 0 ;
	while(iter != (*m_dict).end())
	{
	//std::cout << "dict word: " << iter -> first << std::endl ;
	//std::cout <<"_________" << ++line << "_________________"<< std::endl ;
	satistic(*iter);
	iter ++ ;
	}
	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpq $0x0, 0x8(%rdi)
je 0x7973
movq %rdi, %rbx
xorl %edx, %edx
leaq -0x48(%rbp), %r13
leaq -0x68(%rbp), %r15
movq 0x5759(%rip), %r12      # 0xcfd0
xorl %r14d, %r14d
movq (%rbx), %rax
cmpb $0x0, (%rax,%rdx)
js 0x78b2
movl $0x1, %ecx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x32e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x3370
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x78e2
callq 0x3280
jmp 0x78e2
movl $0x2, %ecx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x32e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x3370
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x78df
callq 0x3280
incl %r14d
movq 0x40(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x855c
addq $0x8, %r13
cmpq %r13, %rax
je 0x794d
movl $0x16, %edx
movq %r12, %rdi
leaq 0x19bd(%rip), %rsi      # 0x92c6
callq 0x3310
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x52b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7df0
incl %r14d
movslq %r14d, %rdx
cmpq %rdx, 0x8(%rbx)
leaq -0x48(%rbp), %r13
jne 0x787a
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x7973
callq 0x3280
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7986
jmp 0x7986
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x799b
callq 0x3280
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::satistic(std::set<int, std::less<int>, std::allocator<int>>&)
void MyTask::satistic(std::set<int> & iset)
{
	std::set<int>::iterator iter ;
	for( iter = iset.begin() ;  iter != iset.end() ;  iter ++)
	{
		int dist = editdistance(  ((*vecDictPtr_)[ *iter ]).first  );
			if(dist < 3)
			{
				MyResult res ;
				res.word_ = ((*vecDictPtr_)[ *iter ]).first ;
				res.distance_ = dist ;
				res.frequence_ = ((*vecDictPtr_)[ *iter ]).second ; 
				result_.push( res );
			}
	}
	/*
	   std::cout << __LINE__ <<std::endl ;
	   std::cout << "value::first :" << value.first << std::endl ;
	   int dist = editdistance( value.first);
	   if(dist < 3)
	   {
	   MyResult res ;
	   res.m_word = value.first ;
	   res.m_frequence = value.second ;
	   res.m_dist = dist ;
	   m_result.push( res );
	   }
	   */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x7ec8
movq %rdi, %r14
leaq 0x48(%rdi), %r12
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
leaq (%rcx,%rcx,4), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %r14, %rdi
callq 0x79a4
cmpl $0x2, %eax
jg 0x7eb4
movl %eax, %r13d
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
leaq (%rcx,%rcx,4), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3180
movl %r13d, -0x2c(%rbp)
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
movq (%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movl 0x20(%rax,%rcx,8), %eax
movl %eax, -0x30(%rbp)
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
callq 0x80c4
movq 0x48(%r14), %rdi
movq 0x50(%r14), %rsi
callq 0x8127
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7eb4
callq 0x3280
movq %r15, %rdi
callq 0x3320
movq %rax, %r15
cmpq %rbx, %rax
jne 0x7e1c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7eec
callq 0x3280
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/MyCompare.h
// Function: MyCompare::operator()(MyResult const&, MyResult const&)
bool operator()(const MyResult& left, const MyResult& right)
        {
            if(left.distance_ > right.distance_)
            {
                return true ;
            }
            else if(left.distance_ == right.distance_ && 
                    left.frequence_ < right.frequence_)
            {
                return true ;
            }
            else if(left.distance_ == right.distance_ && 
                    left.frequence_ == right.frequence_ && 
                    left.word_ > right.word_)
            {
                return true ;
            }
            else 
            {
                return false ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x24(%rdx), %eax
movb $0x1, %bl
cmpl %eax, 0x24(%rsi)
jg 0x854b
jne 0x8549
movl 0x20(%rdx), %eax
cmpl %eax, 0x20(%rsi)
jl 0x854b
jne 0x8549
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3050
testl %eax, %eax
jg 0x854b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x4976
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./src/MyCacheThread.cpp
// Function: MyCacheThread::run()
void MyCacheThread::run()
{
	while(true)
	{
		sleep(60);
		scan_cache();	
		std::cout << "scan cache" << std::endl ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x49c0(%rip), %r14      # 0xcfd0
leaq 0xcc7(%rip), %r15       # 0x92de
movl $0x3c, %edi
callq 0x3210
movq %rbx, %rdi
callq 0x8662
movl $0xa, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
jmp 0x8617
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./src/MyCacheThread.cpp
// Function: MyCacheThread::get_related(ThreadPool*)
void MyCacheThread::get_related(ThreadPool* threadPoolPtr)
{
    threadPoolPtr_ = threadPoolPtr;
    
    std::vector<MyThread>::iterator  iter1  = (threadPoolPtr_ -> vecThreads_).begin();
    std::vector<MyThread*>::iterator iter2  = vecWorkThreadPtr_.begin() ;
    
    while(iter2 != vecWorkThreadPtr_.end() && 
          iter1 != (threadPoolPtr_ -> vecThreads_).end() )
    {
        *iter2 = &(*iter1);
        iter1++;
        iter2++;
    }
}

// Assembly:
movq %rsi, 0x58(%rdi)
movq 0x60(%rdi), %rax
cmpq 0x68(%rdi), %rax
je 0x88eb
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rcx
movq 0x58(%rdi), %rdx
cmpq 0x10(%rdx), %rcx
je 0x88ea
movq %rcx, (%rax)
addq $0xc0, %rcx
addq $0x8, %rax
cmpq 0x68(%rdi), %rax
jne 0x88cc
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jianxinzhou[P]Smart/./include/MyCache.h
// Function: MyCache::write_to_file(std::basic_ofstream<char, std::char_traits<char>>&)
void write_to_file(std::ofstream& outfile)
        {
            hashmapLock_.lock();
            for(std::unordered_map<std::string, std::string>::iterator iter = hashmap_.begin(); 
                iter != hashmap_.end();
                ++iter)
            {
                outfile << iter -> first << "\t" << iter -> second << std::endl ;
            }
            hashmapLock_.unlock();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x33f0
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x8982
leaq 0x9ec(%rip), %r15       # 0x9308
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
movq %rbx, %rdi
callq 0x3310
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3310
movq 0x28(%r13), %rsi
movq 0x30(%r13), %rdx
movq %r12, %rdi
callq 0x3310
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq (%r13), %r13
testq %r13, %r13
jne 0x891c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/ymd.c
// Function: day2ymd
YMD day2ymd(int nDate)
{
    YMD		x;
    nDate -= -BASE_DATE
            + (nDate < -72871 ? 3 : nDate < -36465 ? 2 : nDate < 59 ? 1 : nDate > 109631 ? -2 : nDate > 73107 ? -1 : 0);

    x.yyyy = (nDate * 4  - 1)/ 1461;
    nDate -= (x.yyyy * 1461)/ 4;
    x.mm = (nDate * 32 - 17) / 979;
    x.dd = nDate - (x.mm * 979 + 17) / 32;

    if (x.mm > 9)   x.mm -= 9, ++x.yyyy; 
    else	    x.mm += 3;

    return  x;
}

// Assembly:
movl $0xa96d5, %edx          # imm = 0xA96D5
cmpl $0xfffee359, %edi       # imm = 0xFFFEE359
jl 0x50ee
movl $0xa96d6, %edx          # imm = 0xA96D6
cmpl $0xffff718f, %edi       # imm = 0xFFFF718F
jl 0x50ee
movl $0xa96d7, %edx          # imm = 0xA96D7
cmpl $0x3b, %edi
jl 0x50ee
movl $0xa96da, %edx          # imm = 0xA96DA
cmpl $0x1ac3f, %edi          # imm = 0x1AC3F
ja 0x50ee
cmpl $0x11d94, %edi          # imm = 0x11D94
movl $0xa96d8, %edx          # imm = 0xA96D8
sbbl $-0x1, %edx
addl %edi, %edx
leal -0x1(,%rdx,4), %eax
cltq
imulq $0x166db073, %rax, %rax # imm = 0x166DB073
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
sarl $0x7, %eax
addl %ecx, %eax
imull $0x5b5, %eax, %ecx      # imm = 0x5B5
shrl $0x2, %ecx
subl %ecx, %edx
movl %edx, %ecx
shll $0x5, %ecx
addl $-0x11, %ecx
movslq %ecx, %rcx
imulq $0x21788c29, %rcx, %rcx # imm = 0x21788C29
movq %rcx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rcx
sarl $0x7, %ecx
leal (%rcx,%rsi), %edi
cmpl $0xa, %edi
sbbl $-0x1, %eax
cmpl $0xa, %edi
leal -0x9(%rcx,%rsi), %r8d
leal 0x3(%rcx,%rsi), %ecx
cmovael %r8d, %ecx
imull $0x3d3, %edi, %esi      # imm = 0x3D3
addl $0x11, %esi
shrl $0x5, %esi
subl %esi, %edx
shlq $0x20, %rcx
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hugosantos[P]dbeacon/dbeacon.cpp
// Function: send_report(int)
int send_report(int type) {
	int len;

	len = build_report(buffer, bufferLen, type == SSM_REPORT ? STATS_REPORT : type, true);
	if (len < 0)
		return len;

	int res;

	if (type == SSM_REPORT) {
		if ((res = sendto(mcastSock, buffer, len, 0, ssmProbeAddr.saddr(), ssmProbeAddr.addrlen())) < 0)
			d_log(LOG_DEBUG, "Failed to send SSM report: %s", strerror(errno));
		else
			bytesSent += res;
	} else {
		for (vector<address>::const_iterator i = redist.begin();
				i != redist.end(); ++i) {
			char tmp[64];

			if (verbose)
				d_log(LOG_DEBUG, "Sending Report to %s",
					i->to_string(tmp, sizeof(tmp)));

			if ((res = sendto(mcastSock, buffer, len, 0, i->saddr(),
					i->addrlen())) < 0)
				d_log(LOG_DEBUG, "Failed to send report to %s: %s",
					i->to_string(tmp, sizeof(tmp)), strerror(errno));
			else
				bytesSent += res;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edi, %ebx
cmpl $0x53, %edi
movl $0x52, %edx
cmovnel %edi, %edx
leaq 0xc730(%rip), %rdi      # 0x128e0
movl $0x2000, %esi           # imm = 0x2000
movl $0x1, %ecx
callq 0xa82c
testl %eax, %eax
js 0x62fa
cmpl $0x53, %ebx
jne 0x621b
movl 0xc682(%rip), %ebx      # 0x12854
movl %eax, %r14d
leaq 0xc42c(%rip), %r15      # 0x12608
movq %r15, %rdi
callq 0xa140
movq %rax, %r12
movq %r15, %rdi
callq 0x9ebc
leaq 0xc6ea(%rip), %rsi      # 0x128e0
movl %ebx, %edi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
movl %eax, %r9d
callq 0x3040
testl %eax, %eax
js 0x6309
addl %eax, 0xe6e2(%rip)      # 0x148f8
jmp 0x62fa
movq 0xc4ee(%rip), %rbx      # 0x12710
cmpq 0xc4ef(%rip), %rbx      # 0x12718
je 0x62fa
movl %eax, %r14d
leaq 0xc6a7(%rip), %r15      # 0x128e0
movq %rsp, %r12
cmpl $0x0, 0xc2f5(%rip)      # 0x12538
je 0x6270
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0xa4ca
movl $0x7, %edi
leaq 0x72b1(%rip), %rsi      # 0xd517
movq %rax, %rdx
xorl %eax, %eax
callq 0x3fdb
movl 0xc5dd(%rip), %r13d     # 0x12854
movq %rbx, %rdi
callq 0x9eb8
movq %rax, %rbp
movq %rbx, %rdi
callq 0x9ebc
movl %r13d, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
movl %eax, %r9d
callq 0x3040
testl %eax, %eax
js 0x62ac
addl %eax, 0xe64e(%rip)      # 0x148f8
jmp 0x62e9
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0xa4ca
movq %rax, %r13
callq 0x3030
movl (%rax), %edi
callq 0x3140
movl $0x7, %edi
leaq 0x7250(%rip), %rsi      # 0xd52c
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3fdb
subq $-0x80, %rbx
cmpq 0xc424(%rip), %rbx      # 0x12718
jne 0x623c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3030
movl (%rax), %edi
callq 0x3140
leaq 0x71dd(%rip), %rsi      # 0xd4f9
movl $0x7, %edi
movq %rax, %rdx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fdb
// File: /workspace/github_cpp_makefile_star2_O3/hugosantos[P]dbeacon/dbeacon.cpp
// Function: sendLeaveReport
void sendLeaveReport(int) {
	send_report(LEAVE_REPORT);
	if (daemonize && pidfile)
		unlink(pidfile);
	exit(0);
}

// Assembly:
pushq %rax
movl $0x56, %edi
callq 0x618e
movq 0xc351(%rip), %rdi      # 0x12748
testq %rdi, %rdi
setne %al
andb 0xc341(%rip), %al       # 0x12744
cmpb $0x1, %al
jne 0x640c
callq 0x31a0
xorl %edi, %edi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/hugosantos[P]dbeacon/dbeacon.cpp
// Function: show_version()
void show_version() {
	fprintf(stderr, "\n");
	fprintf(stderr, "dbeacon - a Multicast Beacon %s\n", versionInfo);
	fprintf(stderr, "\n");
	fprintf(stderr, "  Copyright (c) 2005-7, Hugo Santos <hugo@fivebits.net>\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "  http://fivebits.net/proj/dbeacon\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "  o Ideas, IPv4 port, SSM pushing by Hoerdt Mickael;\n");
	fprintf(stderr, "  o Ideas and testing by Sebastien Chaumontet;\n");
	fprintf(stderr, "  o SSM Ping originaly by Stig Venaas\n");
	fprintf(stderr, "    - first proposed by Pavan Namburi, Kamil Sarac and Kevin C. Almeroth;\n");
	fprintf(stderr, "  o Bernhard Schmidt provided valuable resources and helped during testing.\n");
	fprintf(stderr, "\n");

	exit(1);
}

// Assembly:
pushq %rbx
movq 0xbbb5(%rip), %rbx      # 0x11fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3480
movq (%rbx), %rdi
leaq 0x676e(%rip), %rsi      # 0xcba0
leaq 0x6788(%rip), %rdx      # 0xcbc1
xorl %eax, %eax
callq 0x34e0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3480
movq (%rbx), %rcx
leaq 0x677a(%rip), %rdi      # 0xcbd1
movl $0x38, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3480
movq (%rbx), %rcx
leaq 0x678d(%rip), %rdi      # 0xcc0a
movl $0x23, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3480
movq (%rbx), %rcx
leaq 0x678b(%rip), %rdi      # 0xcc2e
movl $0x35, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rcx
leaq 0x67a8(%rip), %rdi      # 0xcc64
movl $0x2f, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rcx
leaq 0x67bf(%rip), %rdi      # 0xcc94
movl $0x26, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rcx
leaq 0x67cd(%rip), %rdi      # 0xccbb
movl $0x4a, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rcx
leaq 0x67ff(%rip), %rdi      # 0xcd06
movl $0x4c, %esi
movl $0x1, %edx
callq 0x3650
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3480
movl $0x1, %edi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/hugosantos[P]dbeacon/dbeacon.cpp
// Function: insert_sorted_event(timer&)
void insert_sorted_event(timer &t) {
	uint32_t accum = 0;

	tq_def::iterator i = timers.begin();

	while (1) {
		if (i == timers.end() || (accum + i->target) >= t.interval)
			break;
		accum += i->target;
		++i;
	}

	t.target = t.interval - accum;

	if (i != timers.end())
		i->target -= t.target;

	if (timers.empty()) {
		lastclk = get_timestamp();
		taccum = 0;
	}

	timers.insert(i, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc32d(%rip), %rax      # 0x12868
leaq 0xc326(%rip), %rcx      # 0x12868
movl 0x4(%rdi), %edx
cmpq %rcx, %rax
je 0x6565
xorl %edi, %edi
movq %rax, %r14
movl 0x18(%r14), %esi
addl %edi, %esi
cmpl %edx, %esi
jae 0x6571
movq (%r14), %r14
movl %esi, %edi
cmpq %rcx, %r14
jne 0x654f
jmp 0x6567
xorl %esi, %esi
subl %esi, %edx
movl %edx, 0x8(%rbx)
movq %rcx, %r14
jmp 0x657a
subl %edi, %edx
movl %edx, 0x8(%rbx)
subl %edx, 0x18(%r14)
cmpq %rcx, %rax
jne 0x6595
callq 0xa61c
movq %rax, 0xc2f5(%rip)      # 0x12880
movl $0x0, 0xc2f3(%rip)      # 0x12888
movl $0x20, %edi
callq 0x33c0
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3050
incq 0xc2ba(%rip)            # 0x12878
addq $0x8, %rsp
popq %rbx
popq %r14
retq