LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdi, %rbx
movsd 0x705a(%rip), %xmm2     # 0xe8b0
leaq 0x28(%rbp), %r15
leaq -0x70(%rbp), %r12
leaq -0x58(%rbp), %r13
movsd 0x703e(%rip), %xmm0     # 0xe8a8
ucomisd %xmm2, %xmm0
jbe 0x78f5
movq 0xc0(%rbx), %r14
movq %r12, %rdi
movq %r15, %rsi
movapd %xmm2, %xmm0
movapd %xmm2, -0x40(%rbp)
callq 0x627c
movq %r13, %rdi
leaq 0x10(%rbp), %rsi
movq %r12, %rdx
callq 0x61e0
movq -0x48(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x58(%rbp), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x8d1c
movsd 0x6fef(%rip), %xmm2     # 0xe8b0
ucomisd %xmm0, %xmm2
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
movapd %xmm1, %xmm2
movsd 0x6fde(%rip), %xmm3     # 0xe8b8
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd -0x40(%rbp), %xmm2
addsd %xmm1, %xmm2
jbe 0x7862
movapd %xmm2, %xmm0
cmpltsd 0x6fa6(%rip), %xmm0     # 0xe8a8
andpd %xmm0, %xmm2
movsd 0x6f2a(%rip), %xmm1     # 0xe838
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d25(%rip), %xmm1     # 0xe678
xorpd %xmm0, %xmm0
callq 0xa500
ucomisd 0x20(%r15), %xmm0
jbe 0x79eb
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x6cfd(%rip), %xmm1     # 0xe678
callq 0xa500
movsd %xmm0, -0x30(%rbp)
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x6ce0(%rip), %xmm1     # 0xe678
callq 0xa500
movsd -0x30(%rbp), %xmm1
mulsd 0x6f26(%rip), %xmm1     # 0xe8d0
movsd %xmm1, -0x30(%rbp)
addsd %xmm0, %xmm0
addsd 0x6e7d(%rip), %xmm0     # 0xe838
movsd %xmm0, -0x48(%rbp)
mulsd %xmm0, %xmm0
movsd 0x6cac(%rip), %xmm1     # 0xe678
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
ucomisd 0x6ea4(%rip), %xmm1     # 0xe880
jb 0x7a8a
sqrtsd %xmm0, %xmm0
jmp 0x7a8f
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 0x673a
leaq -0xa8(%rbp), %r12
movsd 0x6e94(%rip), %xmm0     # 0xe8c0
movsd 0x6e94(%rip), %xmm1     # 0xe8c8
movsd 0x6dfc(%rip), %xmm2     # 0xe838
movq %r12, %rdi
callq 0x61cc
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x61e0
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x6575
movsd 0x28(%r15), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x627c
jmp 0x7b01
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 0x61cc
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x61e0
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6575
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_O1/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 0x5c5d(%rip), %xmm0     # 0xe9f0
movsd %xmm0, -0x30(%rbp)
movsd 0x5c58(%rip), %xmm2     # 0xe9f8
movsd 0x58d0(%rip), %xmm0     # 0xe678
leaq -0x90(%rbp), %r12
leaq -0x78(%rbp), %r13
leaq -0x60(%rbp), %r14
movsd %xmm0, -0x38(%rbp)
movsd 0x5c3c(%rip), %xmm0     # 0xea00
ucomisd %xmm2, %xmm0
jbe 0x8eee
movq %r12, %rdi
leaq 0x28(%rbp), %rsi
movsd %xmm2, -0x40(%rbp)
movapd %xmm2, %xmm0
callq 0x627c
movq %r13, %rdi
leaq 0x10(%rbp), %rsi
movq %r12, %rdx
callq 0x61e0
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movupd -0x78(%rbp), %xmm0
movapd %xmm0, -0x60(%rbp)
cmpl $0x0, (%rbx)
jle 0x8e20
xorl %r15d, %r15d
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
incl %r15d
cmpl (%rbx), %r15d
jl 0x8e0c
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x60(%rbp), %xmm0
movups %xmm0, (%rsp)
movsd 0x583f(%rip), %xmm0     # 0xe678
callq 0x6971
movapd %xmm0, %xmm3
movsd 0x5bbe(%rip), %xmm0     # 0xea08
ucomisd %xmm3, %xmm0
ja 0x8e85
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm0, %xmm4
divsd %xmm1, %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x5a03(%rip), %xmm0     # 0xe880
jb 0x8e8c
sqrtsd %xmm0, %xmm0
jmp 0x8ea5
movsd -0x40(%rbp), %xmm2
jmp 0x8ed6
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x48(%rbp)
callq 0x3220
movsd -0x48(%rbp), %xmm4
movsd -0x30(%rbp), %xmm3
movsd -0x40(%rbp), %xmm2
mulsd 0x48(%rbx), %xmm0
movapd %xmm2, %xmm1
subsd %xmm4, %xmm1
maxsd 0x59c1(%rip), %xmm1     # 0xe880
divsd %xmm1, %xmm0
minsd -0x38(%rbp), %xmm0
addsd %xmm3, %xmm2
movsd %xmm0, -0x38(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd 0x5b2a(%rip), %xmm0     # 0xea08
ucomisd %xmm3, %xmm0
jbe 0x8dbc
xorpd %xmm0, %xmm0
jmp 0x8ef3
movsd -0x38(%rbp), %xmm0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6607
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6310
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x6887
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x68e9
movq %rbx, %rdi
callq 0x681d
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x68e9
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x6887
movq %rbx, %rdi
callq 0x67b3
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_O1/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), %eax
notl %eax
movl %eax, 0x28(%rdi)
testq %rdx, %rdx
je 0xd1e1
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 0xd1aa
incq %r8
cmpq %rdx, %r8
jne 0xd1a8
notl 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd5e7
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 0xd5a5
jmp 0xd5ea
movl %r10d, %r8d
shll $0x10, %eax
orl %r8d, %eax
movl %eax, 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x592e
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 0x5f24
leaq 0x70(%r15), %r12
movq %r12, %rdi
callq 0x59bc
leaq 0x98(%r15), %rdi
movq %r12, %rsi
callq 0x5a6a
movb $0x0, 0xd0(%r15)
leaq 0xd8(%r15), %r13
leaq -0x3c(%rbp), %rsi
movq %r13, %rdi
callq 0x5b20
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 0x88fe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x38(%rbp)
movq %r13, %rdi
callq 0x5b7e
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 0x6154
jmp 0x4298
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
callq 0x5bc0
movq -0x38(%rbp), %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x629a
addq $0xc0, %r14
jmp 0x4581
addq $0xd8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x629a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x640c
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_O1/jianxinzhou[P]Smart/./include/MyConf.h
// Function: MyConf::setIndex(int)
void setIndex(int vecDictIndex)
        {
            std::string word, letter; // 单词，以及单词中的每一个字母（汉字）
            word = vecDict_[vecDictIndex].first ; // 根据词典的下标来找每一个单词（词典的下标正是我们传给setIndex的参数）
            // 遍历单词的每一个字母，制作索引
            for(int index = 0; 
                index != word.size(); 
                ++index)
            {
                // 中文
                if(word[index] & (1 << 7))
                {
                    letter = word.substr(index, 2);
                    index ++ ;
                }else 
                {
                    letter = word.substr(index, 1) ;
                }
                mapIndex_[letter].insert(vecDictIndex); //将包含这个字母的单词 所在vector的下标放入set中
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movslq %esi, %rax
leaq (%rax,%rax,4), %rsi
shlq $0x3, %rsi
addq 0x238(%rdi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3180
cmpq $0x0, -0x48(%rbp)
je 0x48b5
addq $0x250, %rbx            # imm = 0x250
xorl %edx, %edx
leaq -0x90(%rbp), %r14
leaq -0x70(%rbp), %r12
leaq -0x2c(%rbp), %r13
xorl %r15d, %r15d
movq -0x50(%rbp), %rax
cmpb $0x0, (%rax,%rdx)
js 0x485b
movl $0x1, %ecx
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x32e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3370
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x488f
callq 0x3280
jmp 0x488f
movl $0x2, %ecx
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x32e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3370
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x488c
callq 0x3280
incl %r15d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x52ae
movq %rax, %rdi
movq %r13, %rsi
callq 0x5746
incl %r15d
movslq %r15d, %rdx
cmpq %rdx, -0x48(%rbp)
jne 0x481e
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x48c7
callq 0x3280
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x48d9
callq 0x3280
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48ee
jmp 0x48ee
jmp 0x48ee
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x4903
callq 0x3280
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x4915
callq 0x3280
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59d4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x75f5(%rip), %rdi      # 0xcfd0
leaq 0x3649(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x3877(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3637(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x36e8(%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 0x3842(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x36c5(%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_O1/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 0x5a89
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x7540(%rip), %rdi      # 0xcfd0
leaq 0x3594(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x37c2(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3582(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3661(%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 0x376e(%rip), %rsi      # 0x9264
movq %rax, %rdi
callq 0x32a0
leaq 0x3643(%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_O1/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 0x6ff3(%rip), %rax      # 0xcd20
movq %rax, (%rdi)
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x3360
testl %eax, %eax
jne 0x5d50
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x7279(%rip), %rdi      # 0xcfd0
leaq 0x32cd(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x34fb(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x32bb(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x3347(%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 0x34c6(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x3324(%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_O1/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 0x62e5
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 0x62ea
leaq 0x18(%rbx), %rdi
leaq 0x12c(%rip), %rdx       # 0x63fe
movq %r14, %rsi
movq %rbx, %rcx
callq 0x34d0
testl %eax, %eax
jne 0x6368
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6cdf(%rip), %rdi      # 0xcfd0
leaq 0x2d33(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x2f61(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2d21(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2dad(%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 0x2f2c(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x2e2b(%rip), %rsi      # 0x9191
jmp 0x63e4
movq 0x6c61(%rip), %rdi      # 0xcfd0
leaq 0x2cb5(%rip), %rsi      # 0x902b
callq 0x32a0
leaq 0x2ee3(%rip), %rbx      # 0x9265
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2ca3(%rip), %rsi      # 0x9037
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
leaq 0x2d2f(%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 0x2eae(%rip), %rsi      # 0x9283
movq %rax, %rdi
callq 0x32a0
leaq 0x2dc9(%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_O1/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 0x66d6(%rip), %r14      # 0xcfd0
leaq 0x290e(%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 %rbx, -0x38(%rbp)
movq 0x58(%rbx), %rax
movq (%rax), %r14
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28c4(%rip), %rsi      # 0x9213
leaq 0x28c5(%rip), %rdx      # 0x921b
leaq -0x58(%rbp), %rdi
callq 0x497a
addq $0x208, %r14            # imm = 0x208
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x4728
movq (%rax), %rsi
leaq -0xc0(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x3120
movq -0x38(%rbp), %rax
leaq 0x60(%rax), %r14
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x6aae
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69b1
callq 0x3280
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x69bf
callq 0x3280
leaq -0x78(%rbp), %r13
xorl %ebx, %ebx
leaq -0xc0(%rbp), %r15
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq -0xb0(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movq %rbx, -0xb8(%rbp)
movb $0x0, -0xb0(%rbp)
leaq 0x238(%rax), %rcx
movq %rcx, -0x88(%rbp)
addq $0x250, %rax            # imm = 0x250
movq %rax, -0x80(%rbp)
movq %rbx, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movups %xmm0, -0x28(%r13)
movq %r15, %rsi
callq 0x6caa
movl %eax, %r12d
testb %al, %al
je 0x6a45
movq %r15, %rdi
movq %r14, %rsi
callq 0x7500
movq %r15, %rdi
callq 0x46b6
testb %r12b, %r12b
jne 0x69cc
jmp 0x6a51
leaq -0xc0(%rbp), %rdi
callq 0x46b6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a82
callq 0x3280
jmp 0x6a82
jmp 0x6a7f
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6aa6
callq 0x3280
jmp 0x6aa6
movq %rax, %rbx
jmp 0x6aa6
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x46b6
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6be2
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 0x6b94
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4c7e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6de0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x6b7a
callq 0x3280
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x6b28
callq 0x3280
jmp 0x6b28
leaq -0x2b0(%rbp), %rdi
callq 0x30a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6bb2
callq 0x3280
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x6bc4
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 0x63e7(%rip), %rdi      # 0xcfd0
leaq 0x262c(%rip), %rsi      # 0x921c
movl $0xc, %edx
callq 0x3310
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x63c8(%rip), %rdi      # 0xcfd0
callq 0x3310
movq %rax, %rdi
callq 0x3150
movl $0x10, %edi
callq 0x3160
movq %rax, %r14
leaq 0x2600(%rip), %rsi      # 0x9229
movq %rax, %rdi
callq 0x3110
movq 0x63b8(%rip), %rsi      # 0xcff0
movq 0x6389(%rip), %rdx      # 0xcfc8
movq %r14, %rdi
callq 0x3490
movq %rax, %rbx
movq %r14, %rdi
callq 0x3200
jmp 0x6c95
movq %rax, %rbx
jmp 0x6c95
jmp 0x6c6e
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x46f2
jmp 0x6c71
jmp 0x6c6e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6c83
callq 0x3280
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x6c95
callq 0x3280
leaq -0x2b0(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq 0x70(%rdi), %r15
movq %r15, %rdi
callq 0x33f0
movb 0xd0(%r14), %bl
cmpb $0x1, %bl
jne 0x6db8
leaq 0xa0(%r14), %r13
movq 0x50(%r14), %rax
cmpq 0x30(%r14), %rax
jne 0x6d0a
movq 0x98(%r14), %rsi
movq %r13, %rdi
callq 0x3420
movb 0xd0(%r14), %bl
testb %bl, %bl
jne 0x6ce1
jmp 0x6db8
testb %bl, %bl
je 0x6db8
movq %r15, -0x30(%rbp)
movq 0x30(%r14), %r15
addq $0x20, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x3180
movq 0x40(%r15), %rax
movq %rax, 0x40(%r12)
movups 0x20(%r15), %xmm0
movups 0x30(%r15), %xmm1
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x20(%r12)
addq $0x48, %r12
addq $0x48, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x71d0
movq %r14, %rdi
callq 0x7480
movq -0x30(%rbp), %rdi
callq 0x3220
movq %r13, %rdi
callq 0x30f0
movq 0x6255(%rip), %r14      # 0xcfd0
leaq 0x24be(%rip), %rsi      # 0x9240
movl $0x8, %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
jmp 0x6dcf
movq %r15, %rdi
callq 0x3220
addq $0xa0, %r14
movq %r14, %rdi
callq 0x30f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7949
movq %rdi, %rbx
xorl %edx, %edx
leaq -0x48(%rbp), %r13
leaq -0x68(%rbp), %r15
movq 0x5771(%rip), %r12      # 0xcfd0
xorl %r14d, %r14d
movq (%rbx), %rax
cmpb $0x0, (%rax,%rdx)
js 0x789a
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 0x78ca
callq 0x3280
jmp 0x78ca
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 0x78c7
callq 0x3280
incl %r14d
movq 0x40(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x85a6
addq $0x8, %r13
cmpq %r13, %rax
je 0x7935
movl $0x16, %edx
movq %r12, %rdi
leaq 0x19d5(%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 0x52ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7df0
incl %r14d
movslq %r14d, %rdx
cmpq %rdx, 0x8(%rbx)
leaq -0x48(%rbp), %r13
jne 0x7862
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x795b
callq 0x3280
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x796e
jmp 0x796e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x7983
callq 0x3280
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x798c
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 0x80cc
movq 0x48(%r14), %rdi
movq 0x50(%r14), %rsi
callq 0x812f
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_O1/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(%rsi), %eax
movl 0x24(%rdx), %ecx
movb $0x1, %bl
cmpl %ecx, %eax
jg 0x8595
jne 0x8593
movl 0x20(%rsi), %edi
cmpl 0x20(%rdx), %edi
jl 0x8595
cmpl %ecx, %eax
jne 0x8593
movl 0x20(%rsi), %eax
cmpl 0x20(%rdx), %eax
jne 0x8593
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3050
testl %eax, %eax
jg 0x8595
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x496c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4978(%rip), %r14      # 0xcfd0
leaq 0xc7f(%rip), %r15       # 0x92de
movl $0x3c, %edi
callq 0x3210
movq %rbx, %rdi
callq 0x86aa
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 0x865f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8933
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rcx
movq 0x58(%rdi), %rdx
cmpq 0x10(%rdx), %rcx
je 0x8932
movq %rcx, (%rax)
addq $0xc0, %rcx
addq $0x8, %rax
cmpq 0x68(%rdi), %rax
jne 0x8914
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89ca
leaq 0x9a4(%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 0x8964
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_O1/ctSkennerton[P]fxtract/util/ymd.c
// Function: ymd2day
int ymd2day(YMD x)
{
    if (x.mm > 2)  x.mm -= 3; else x.mm += 9, --x.yyyy;

    // This is sufficient back to 1500-03-01. 1753 is the start of Gregorian Calendar.
    int days = (x.yyyy*1461)/4 + (x.mm*979 + 17)/32 + x.dd - BASE_DATE;
    return days 
            + (days < -72871-3) + (days < -36465-2) + (days < 59-1) 
            - (days >  73107+1) - (days > 109631+2); // Mar 1 (1700,1800,1900,2100,2200)
}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
cmpq $0x3, %rax
sbbl $0x0, %edi
leal -0x3(%rax), %ecx
leal 0x9(%rax), %edx
cmpq $0x3, %rax
cmovael %ecx, %edx
imull $0x5b5, %edi, %eax      # imm = 0x5B5
shrl $0x2, %eax
imull $0x3d3, %edx, %ecx      # imm = 0x3D3
addl $0x11, %ecx
shrl $0x5, %ecx
addl %esi, %eax
leal (%rax,%rcx), %edx
addl %eax, %ecx
addl $0xfff56928, %ecx       # imm = 0xFFF56928
xorl %eax, %eax
cmpl $0xfffee356, %ecx       # imm = 0xFFFEE356
setl %al
addl %eax, %edx
addl $0xfff56928, %edx       # imm = 0xFFF56928
xorl %esi, %esi
cmpl $0xffff718d, %ecx       # imm = 0xFFFF718D
setl %sil
xorl %eax, %eax
cmpl $0x3a, %ecx
setl %al
addl %esi, %eax
addl %edx, %eax
xorl %edx, %edx
cmpl $0x11d95, %ecx          # imm = 0x11D95
setge %dl
subl %edx, %eax
xorl %edx, %edx
cmpl $0x1ac42, %ecx          # imm = 0x1AC42
setge %dl
subl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5119
movl $0xa96d6, %edx          # imm = 0xA96D6
cmpl $0xffff718f, %edi       # imm = 0xFFFF718F
jl 0x5119
movl $0xa96d7, %edx          # imm = 0xA96D7
cmpl $0x3b, %edi
jl 0x5119
movl $0xa96da, %edx          # imm = 0xA96DA
cmpl $0x1ac3f, %edi          # imm = 0x1AC3F
jg 0x5119
xorl %edx, %edx
cmpl $0x11d94, %edi          # imm = 0x11D94
setge %dl
orl $0xa96d8, %edx          # imm = 0xA96D8
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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/hugosantos[P]dbeacon/dbeacon.cpp
// Function: d_logv(int, char const*, __va_list_tag*)
static void d_logv(int level, const char *format, va_list vl)
{
	char buffer[256];
	vsnprintf(buffer, sizeof(buffer), format, vl);

	if (use_syslog && past_init) {
		syslog(level, "%s",buffer);
	} else {
		char tbuf[64];
		timeval tv;
		gettimeofday(&tv, 0);

		/* Some FreeBSDs' tv.tv_sec isn't time_t */
		time_t tv_sec = tv.tv_sec;
		strftime(tbuf, sizeof(tbuf), "%b %d %H:%M:%S", localtime(&tv_sec));

		fprintf(stderr, "%s.%06u %s\n", tbuf, (uint32_t)tv.tv_usec, buffer);
	}
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %rcx
movq %rsi, %rdx
movl %edi, %ebx
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3230
cmpb $0x1, 0xe6c2(%rip)      # 0x12745
jne 0x40aa
cmpb $0x1, 0xe6ba(%rip)      # 0x12746
jne 0x40aa
leaq 0x8d3c(%rip), %rsi      # 0xcdd1
movq %rsp, %rdx
movl %ebx, %edi
xorl %eax, %eax
callq 0x3070
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
movq %rsp, %rdi
callq 0x3680
jmp 0x40a1
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc6d4(%rip), %rdi      # 0x128e0
movl $0x2000, %esi           # imm = 0x2000
movl $0x1, %ecx
callq 0xa8d8
testl %eax, %eax
js 0x6356
cmpl $0x53, %ebx
jne 0x6277
movl 0xc626(%rip), %ebx      # 0x12854
movl %eax, %r14d
leaq 0xc3d0(%rip), %r15      # 0x12608
movq %r15, %rdi
callq 0xa1ee
movq %rax, %r12
movq %r15, %rdi
callq 0x9f64
leaq 0xc68e(%rip), %rsi      # 0x128e0
movl %ebx, %edi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
movl %eax, %r9d
callq 0x3040
testl %eax, %eax
js 0x6365
addl %eax, 0xe686(%rip)      # 0x148f8
jmp 0x6356
movq 0xc492(%rip), %rbx      # 0x12710
cmpq 0xc493(%rip), %rbx      # 0x12718
je 0x6356
movl %eax, %r14d
leaq 0xc64b(%rip), %r15      # 0x128e0
movq %rsp, %r12
cmpl $0x0, 0xc299(%rip)      # 0x12538
je 0x62cc
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0xa578
movl $0x7, %edi
leaq 0x725c(%rip), %rsi      # 0xd51e
movq %rax, %rdx
xorl %eax, %eax
callq 0x3fdb
movl 0xc581(%rip), %r13d     # 0x12854
movq %rbx, %rdi
callq 0x9f60
movq %rax, %rbp
movq %rbx, %rdi
callq 0x9f64
movl %r13d, %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
movl %eax, %r9d
callq 0x3040
testl %eax, %eax
js 0x6308
addl %eax, 0xe5f2(%rip)      # 0x148f8
jmp 0x6345
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0xa578
movq %rax, %r13
callq 0x3030
movl (%rax), %edi
callq 0x3140
movl $0x7, %edi
leaq 0x71fb(%rip), %rsi      # 0xd533
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3fdb
subq $-0x80, %rbx
cmpq 0xc3c8(%rip), %rbx      # 0x12718
jne 0x6298
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3030
movl (%rax), %edi
callq 0x3140
leaq 0x7188(%rip), %rsi      # 0xd500
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_O1/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 0x61ea
movq 0xc2f5(%rip), %rdi      # 0x12748
testq %rdi, %rdi
setne %al
andb 0xc2e5(%rip), %al       # 0x12744
cmpb $0x1, %al
jne 0x6468
callq 0x31a0
xorl %edi, %edi
callq 0x3450