LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/myListeners/listener12.cpp
// Function: listener1::onListener()
void listener1::onListener()
{
	while(1){
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		EVENT_MSG eventMsg = lisQueue.front();
		switch(eventMsg.eventID)
		{
			case L1_FUN1:
			{
				l1_fun1();
				MY_INFO *myinfo = new MY_INFO();
				msgDataUnPack(eventMsg.msgData, sizeof(MY_INFO), myinfo, -1);
				//cout << "name : " << myinfo.name;
				LOGOUT_COLOR(WHITE, GREEN, "name:%s; age:%d; sex:%c\n",
					myinfo->name.c_str(), myinfo->age, myinfo->sex);
				break;
			}
			case L1_FUN2:
			{
				int sum;
				msgDataUnPack(eventMsg.msgData, sizeof(int), &sum, -1);
				l1_fun2(sum);
				break;
			}
			default:
				break;
		}
		lisQueue.pop();
		pthread_mutex_unlock(&mutex);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x8(%rdi), %r15
leaq 0x60(%rdi), %r12
leaq 0x4(%rsp), %rbp
movq %r14, %rdi
callq 0x21a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21b0
movq 0x70(%rbx), %rsi
movl $0x84, %edx
movq %rbp, %rdi
callq 0x20f0
movl 0x4(%rsp), %eax
cmpl $0x1, %eax
je 0x2784
testl %eax, %eax
jne 0x27b2
leaq 0x1985(%rip), %rdi      # 0x4090
xorl %eax, %eax
callq 0x30ef
movl $0x28, %edi
callq 0x2160
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
addq $0x10, %rax
movq %rax, (%r13)
movq %rcx, 0x8(%r13)
movb $0x0, 0x10(%r13)
movl $0x28, %edx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2230
movq (%r13), %rcx
movl 0x20(%r13), %r8d
movsbl 0x24(%r13), %r9d
movl $0x7, %edi
movl $0x2, %esi
leaq 0x1978(%rip), %rdx      # 0x40f3
xorl %eax, %eax
callq 0x334f
jmp 0x27b2
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2230
movl (%rsp), %esi
leaq 0x191e(%rip), %rdi      # 0x40c9
xorl %eax, %eax
callq 0x30ef
movq %r12, %rdi
callq 0x2922
movq %r14, %rdi
callq 0x20e0
jmp 0x26cb
nop
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/myListeners/listener12.cpp
// Function: listener2::onListener()
void listener2::onListener()
{
	while(1){
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		EVENT_MSG eventMsg = lisQueue.front();
		switch(eventMsg.eventID)
		{
			case L2_FUN1:
				double res;
				msgDataUnPack(eventMsg.msgData, sizeof(double), &res, -1);
				l2_fun1(res);
				break;
			case L2_FUN2:
				int sum;
				msgDataUnPack(eventMsg.msgData, sizeof(int), &sum, -1);
				l2_fun2(sum);
				break;
			default:
				break;
		}
		lisQueue.pop();
		pthread_mutex_unlock(&mutex);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x8(%rdi), %r15
leaq 0x60(%rdi), %r12
leaq 0x18(%rsp), %r13
leaq 0x14(%rsp), %rbp
movq %r14, %rdi
callq 0x21a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21b0
movq 0x70(%rbx), %rsi
movl $0x84, %edx
movq %rbp, %rdi
callq 0x20f0
movl 0x14(%rsp), %eax
cmpl $0x3, %eax
je 0x28dd
cmpl $0x2, %eax
jne 0x290c
movl $0x8, %edx
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x8(%rsp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2230
movsd 0x8(%rsp), %xmm0
leaq 0x1842(%rip), %rdi      # 0x4116
movb $0x1, %al
callq 0x2fd0
jmp 0x290c
movl $0x4, %edx
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x4(%rsp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2230
movl 0x4(%rsp), %esi
leaq 0x1842(%rip), %rdi      # 0x4147
xorl %eax, %eax
callq 0x2fd0
movq %r12, %rdi
callq 0x2922
movq %r14, %rdi
callq 0x20e0
jmp 0x2878
nop
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/myResponsers/responser12.cpp
// Function: responser1::onResponser()
void responser1::onResponser()
{
	while(1){
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		switch(eventMsg.eventID)
		{
			case R1_FUN1:
			{
				r1_fun1();
				/* ������Ϣ�������������ؽ��� */
				MSG_INFO msgInfo;
				msgInfo.resType = RES1;
				msgInfo.msg.eventID = L1_FUN1;
				/* ������new �����ڴ�����ΪMY_INFO �ṹ��
				    ����string ��Ա��ֻ����new ���ܵ�����
				    ���캯����*/
				MY_INFO* myinfo = new MY_INFO(); 
				myinfo->name = "fanchenxin";
				myinfo->age = 27;
				myinfo->sex = 'm';
				msgDataPack(msgInfo.msg.msgData, sizeof(MY_INFO), myinfo, -1);
				sendMsgToListener(msgInfo);
				break;
			}
			case R1_FUN2:
			{
				int a, b;
				msgDataUnPack(eventMsg.msgData, sizeof(int), &a,
					sizeof(int), &b, -1);
				int sum = r1_fun2(a, b);
				cout << "(1)The sum = " << sum << endl;

				/* ������Ϣ�������������ؽ��� */
				MSG_INFO msgInfo;
				msgInfo.resType = RES1;
				msgInfo.msg.eventID = L1_FUN2;
				msgDataPack(msgInfo.msg.msgData, sizeof(int), &sum, -1);
				sendMsgToListener(msgInfo);
				break;
			}
			default:
				break;
		}
		
		pthread_mutex_unlock(&mutex);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
leaq 0x90(%rdi), %r15
leaq 0xc(%rdi), %rax
movq %rax, 0x98(%rsp)
movq 0x3529(%rip), %r13      # 0x5fd8
leaq 0xa0(%rsp), %rbp
movq %r14, %rdi
callq 0x21a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21b0
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
je 0x2b68
testl %eax, %eax
jne 0x2c53
callq 0x29e2
movw $0x0, 0xa0(%rsp)
movl $0x0, 0xa4(%rsp)
movl $0x28, %edi
callq 0x2160
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
addq $0x10, %rax
movq %rax, (%r12)
movq %rcx, 0x8(%r12)
movb $0x0, 0x10(%r12)
movl $0xa, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x1693(%rip), %rcx      # 0x41cf
callq 0x21d0
movl $0x1b, 0x20(%r12)
movb $0x6d, 0x24(%r12)
movl $0x28, %edx
movq %rbx, %rdi
leaq 0xa8(%rsp), %rsi
movq %r12, %rcx
jmp 0x2c30
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x4, %edx
movl $0x4, %r8d
movq %rbx, %rdi
movq 0x98(%rsp), %rsi
leaq 0x94(%rsp), %rcx
leaq 0x90(%rsp), %r9
xorl %eax, %eax
callq 0x2220
movl 0x94(%rsp), %esi
movl 0x90(%rsp), %edx
callq 0x2a26
movl %eax, 0x8c(%rsp)
movl $0xd, %edx
movq %r13, %rdi
leaq 0x1615(%rip), %rsi      # 0x41da
callq 0x2180
movl 0x8c(%rsp), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movw $0x0, 0xa0(%rsp)
movl $0x1, 0xa4(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x8c(%rsp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2200
movl $0x11, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x20e0
jmp 0x2ab7
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/myResponsers/responser12.cpp
// Function: responser2::onResponser()
void responser2::onResponser()
{
	while(1){
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		switch(eventMsg.eventID)
		{
			case R2_FUN1:
			{
				double a, b;
				msgDataUnPack(eventMsg.msgData, sizeof(double), &a,
					sizeof(double), &b, -1);
				double res = r2_fun1(a, b);

				/* ������Ϣ�������� */
				MSG_INFO msgInfo;
				msgInfo.resType = RES2;
				msgInfo.msg.eventID = L2_FUN1;
				msgDataPack(msgInfo.msg.msgData, sizeof(double), &res, -1);
				sendMsgToListener(msgInfo);
				break;
			}
			case R2_FUN2:
			{
				int c, d;
				msgDataUnPack(eventMsg.msgData, sizeof(int), &c,
					sizeof(int), &d, -1);
				int sum = r2_fun2(c, d);
				cout << "(2)The sum is " << sum << endl;

				/* ������Ϣ�������� */
				MSG_INFO msgInfo;
				msgInfo.resType = RES2;
				msgInfo.msg.eventID = L2_FUN2;
				msgDataPack(msgInfo.msg.msgData, sizeof(int), &sum, -1);
				sendMsgToListener(msgInfo);
				break;
			}
			default:
				break;
		}
		
		pthread_mutex_unlock(&mutex);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
leaq 0x90(%rdi), %rbp
leaq 0xc(%rdi), %rax
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %r12
leaq 0x88(%rsp), %r15
leaq 0xb0(%rsp), %r13
movq %r14, 0xa8(%rsp)
movq %r14, %rdi
callq 0x21a0
movq %rbp, %rdi
movq %r14, %rsi
callq 0x21b0
movl 0x8(%rbx), %eax
cmpl $0x3, %eax
je 0x2eb2
cmpl $0x2, %eax
jne 0x2fc2
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x8, %edx
movl $0x8, %r8d
movq %rbx, %rdi
movq 0x98(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq %r12, %r9
xorl %eax, %eax
callq 0x2220
movsd 0x90(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
callq 0x2cca
movsd %xmm0, 0x88(%rsp)
movw $0x1, 0xb0(%rsp)
movl $0x2, 0xb4(%rsp)
movl $0x8, %edx
jmp 0x2f91
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x4, %edx
movl $0x4, %r8d
movq %rbx, %rdi
movq %r15, %r13
movq 0x98(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq %r12, %r15
movq %r12, %r9
xorl %eax, %eax
callq 0x2220
movl 0x90(%rsp), %esi
movl 0xa0(%rsp), %edx
callq 0x2d7e
movl %eax, 0x88(%rsp)
movl $0xe, %edx
movq 0x30cb(%rip), %r12      # 0x5fd8
movq %r12, %rdi
leaq 0x1318(%rip), %rsi      # 0x422f
callq 0x2180
movl 0x88(%rsp), %esi
movq %r12, %rdi
callq 0x2210
movq %rbx, %r14
movq %rbp, %rbx
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbp, %rdi
movq %r15, %r12
movq %r13, %r15
leaq 0xb0(%rsp), %r13
movq %rbx, %rbp
movq %r14, %rbx
movq 0xa8(%rsp), %r14
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movw $0x1, 0xb0(%rsp)
movl $0x3, 0xb4(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
leaq 0xb8(%rsp), %rsi
movq %r15, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2200
movl $0x11, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x20e0
jmp 0x2e20
nop
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/logout/log_out.c
// Function: LOGOUT_NOTICE
void LOGOUT_NOTICE(char* log_format, ...)
{
	struct timespec ts;
	clock_gettime(CLOCK_MONOTONIC, &ts);

	char chLog[1024];
	va_list	w_arg;
	va_start( w_arg, log_format );
	snprintf( chLog, 34, "\033[1;33;42m[%4u:%09u] <N>:  ",  ts.tv_sec, ts.tv_nsec);		
	vsnprintf( chLog+33, 1024 - 34, log_format, w_arg);
	va_end( w_arg );

       int len = strlen(chLog);
       if(chLog[len - 1] == '\n')
            chLog[len - 1] = '\0';

	printf( "%s\033[0m\n", chLog);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4e8, %rsp            # imm = 0x4E8
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x303d
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsp, %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x2120
leaq 0x10(%rsp), %r15
movq %r12, 0x10(%r15)
leaq 0x510(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x11e6(%rip), %rdx      # 0x4263
leaq 0xe0(%rsp), %r14
movl $0x22, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0x101(%rsp), %rdi
movl $0x3de, %esi            # imm = 0x3DE
movq %rbx, %rdx
movq %r15, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0x2090
decl %eax
cltq
cmpb $0xa, 0xe0(%rsp,%rax)
jne 0x30ca
movb $0x0, 0xe0(%rsp,%rax)
leaq 0x11ae(%rip), %rdi      # 0x427f
leaq 0xe0(%rsp), %rsi
xorl %eax, %eax
callq 0x2040
addq $0x4e8, %rsp            # imm = 0x4E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/logout/log_out.c
// Function: LOGOUT_WARNING
void LOGOUT_WARNING(char* log_format, ...)
{
	struct timespec ts;
	clock_gettime(CLOCK_MONOTONIC, &ts);

	char chLog[1024];
	va_list	w_arg;
	va_start( w_arg, log_format );
	snprintf( chLog, 34, "\033[1;31;47m[%4u:%09u] <W>:  ",  ts.tv_sec, ts.tv_nsec);		
	vsnprintf( chLog+33, 1024 - 34, log_format, w_arg);
	va_end( w_arg );

       int len = strlen(chLog);
       if(chLog[len - 1] == '\n')
            chLog[len - 1] = '\0';

	printf( "%s\033[0m\n", chLog);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4e8, %rsp            # imm = 0x4E8
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x315c
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsp, %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x2120
leaq 0x10(%rsp), %r15
movq %r12, 0x10(%r15)
leaq 0x510(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x10eb(%rip), %rdx      # 0x4287
leaq 0xe0(%rsp), %r14
movl $0x22, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0x101(%rsp), %rdi
movl $0x3de, %esi            # imm = 0x3DE
movq %rbx, %rdx
movq %r15, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0x2090
decl %eax
cltq
cmpb $0xa, 0xe0(%rsp,%rax)
jne 0x31e9
movb $0x0, 0xe0(%rsp,%rax)
leaq 0x108f(%rip), %rdi      # 0x427f
leaq 0xe0(%rsp), %rsi
xorl %eax, %eax
callq 0x2040
addq $0x4e8, %rsp            # imm = 0x4E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/fanchenxinok[P]gtest-lcov/logout/log_out.c
// Function: LOGOUT_COLOR
void LOGOUT_COLOR(
    LOG_COLOR forground_color,
    LOG_COLOR background_color,
    char* log_format, ...)
{
	struct timespec ts;
	clock_gettime(CLOCK_MONOTONIC, &ts);

	char chLog[1024];
       char forColValue[3] = {'\0'};
       char backColValue[3] = {'\0'};
       getColorValueStr(background_color, BACKGROUND, backColValue);
       getColorValueStr(forground_color, FORGROUND, forColValue);
	va_list	w_arg;
	va_start( w_arg, log_format );
       snprintf(chLog, 30, "\033[1;%s;%sm[%4u:%09u]   ",
                    forColValue, backColValue,
                    ts.tv_sec, ts.tv_nsec);	
	vsnprintf( chLog+29, 1024 - 30, log_format, w_arg);
	va_end( w_arg );

       int len = strlen(chLog);
       if(chLog[len - 1] == '\n')
            chLog[len - 1] = '\0';

	printf( "%s\033[0m\n", chLog);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f0, %rsp            # imm = 0x4F0
movq %rdx, %rbx
movl %esi, %r12d
movl %edi, %r15d
leaq 0x40(%rsp), %r13
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0x33ba
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
leaq 0x10(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x2120
xorl %eax, %eax
leaq 0xc(%rsp), %rcx
movb %al, 0x2(%rcx)
movw %ax, (%rcx)
leaq 0x8(%rsp), %r8
movw %ax, (%r8)
movb %al, 0x2(%r8)
movb $0x34, (%r8)
leal 0x30(%r12), %eax
cmpl $0x8, %r12d
movzbl %al, %eax
movl $0x30, %edx
cmovael %edx, %eax
movb %al, 0x1(%r8)
movb $0x33, (%rcx)
leal 0x30(%r15), %eax
cmpl $0x8, %r15d
movzbl %al, %eax
cmovael %edx, %eax
movb %al, 0x1(%rcx)
leaq 0x20(%rsp), %r15
movq %r13, 0x10(%r15)
leaq 0x520(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq (%r14), %r9
movq 0x8(%r14), %rax
movq %rax, (%rsp)
leaq 0xe75(%rip), %rdx       # 0x42bf
leaq 0xf0(%rsp), %r14
movl $0x1e, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
leaq 0x10d(%rsp), %rdi
movl $0x3e2, %esi            # imm = 0x3E2
movq %rbx, %rdx
movq %r15, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0x2090
decl %eax
cltq
cmpb $0xa, 0xf0(%rsp,%rax)
jne 0x3497
movb $0x0, 0xf0(%rsp,%rax)
leaq 0xde1(%rip), %rdi       # 0x427f
leaq 0xf0(%rsp), %rsi
xorl %eax, %eax
callq 0x2040
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/olahol[P]cpp-csp/examples/interleave.cpp
// Function: main
int main() {
  csp::Channel<int> chan;
  csp::Scheduler scheduler;

  scheduler.spawn([&]() {
    for (int i = 1; i < 11; i++) {
      std::cout << "put " << i << std::endl;
      chan.put(i);
    }
    chan.put(0);
  });

  scheduler.spawn([&]() {
    while (true) {
      auto i = chan.get();
      if (i == 0) break;
      std::cout << "get " << i << std::endl;
    }
  });

  scheduler.join();

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2704
movl $0x0, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movq %r15, 0x78(%r14)
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0x2140
movq %r15, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl $0x8, %edi
callq 0x2110
movq %rax, %r15
movq $0x0, (%rax)
movl $0x10, %edi
callq 0x2110
leaq 0x2978(%rip), %rcx      # 0x4d48
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
xorl %edx, %edx
callq 0x20f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23f9
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x287a
movl $0x8, %edi
callq 0x2110
movq %rax, %r15
movq $0x0, (%rax)
movl $0x10, %edi
callq 0x2110
leaq 0x2958(%rip), %rcx      # 0x4d88
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
xorl %edx, %edx
callq 0x20f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2459
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x287a
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x248e
movq (%r14), %rdi
cmpq $0x0, (%rdi)
je 0x2488
callq 0x21b0
addq $0x8, %r14
jmp 0x2475
leaq 0x10(%rsp), %rdi
callq 0x2652
movq %rbx, %rdi
callq 0x21e0
leaq 0x30(%rsp), %rdi
callq 0x26b4
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x24bd
jmp 0x24db
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24d0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x24de
movq %rax, %r14
movl $0x8, %esi
movq %r15, %rdi
callq 0x2120
jmp 0x24f2
jmp 0x24ef
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2652
movq %rbx, %rdi
callq 0x21e0
leaq 0x30(%rsp), %rdi
callq 0x26b4
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/olahol[P]cpp-csp/examples/../csp.hpp
// Function: csp::Channel<int>::put(int)
void put(TItem t) {
      std::unique_lock<std::mutex> lock(m);

      cv.wait(lock, [&]() { return (state == 0); });

      queue.push(t);
      state = 1;
      cv.notify_all();

      cv.wait(lock, [&]() { return (state == 2); });

      state = 0;
      cv.notify_all();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x58(%rdi), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x29a2
movb $0x1, 0x8(%r14)
leaq 0x80(%rbx), %r14
cmpl $0x0, 0x50(%rbx)
je 0x28fb
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
cmpl $0x0, 0x50(%rbx)
jne 0x28ea
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x291c
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2929
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x29de
movl $0x1, 0x50(%rbx)
movq %r14, %rdi
callq 0x21a0
cmpl $0x2, 0x50(%rbx)
je 0x2954
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
cmpl $0x2, 0x50(%rbx)
jne 0x2943
movl $0x0, 0x50(%rbx)
movq %r14, %rdi
callq 0x21a0
leaq 0x10(%rsp), %rdi
callq 0x298c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x298c
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/olahol[P]cpp-csp/examples/../csp.hpp
// Function: csp::Channel<int>::get()
TItem get() {
      std::unique_lock<std::mutex> lock(m);
      cv.wait(lock, [&]() { return (state == 1); });

      TItem e = queue.front();
      queue.pop();
      state = 2;
      cv.notify_all();

      return e;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x29a2
movb $0x1, 0x8(%r14)
leaq 0x80(%rbx), %r14
cmpl $0x1, 0x50(%rbx)
je 0x2da4
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
cmpl $0x1, 0x50(%rbx)
jne 0x2d93
movq 0x10(%rbx), %rax
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x2dd8
movl $0x2, 0x50(%rbx)
movq %r14, %rdi
callq 0x21a0
leaq 0x8(%rsp), %rdi
callq 0x298c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::set_goal(unsigned int, unsigned int)
void set_goal(unsigned rows, unsigned cols) {
        d0_ = d1_ = d2_ = 0;
        d0_ |= (rows<<4);
        d0_ |= (cols<<8);
        set_blank(0);
        for( unsigned t = 0; t < rows*cols; ++t )
            set_tile(t, 1+t);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq $0x0, 0x4(%rdi)
movl %edx, %eax
imull %esi, %ebx
shll $0x4, %esi
shll $0x8, %eax
orl %esi, %eax
movl %eax, (%rdi)
testl %ebx, %ebx
je 0x6575
movq %rdi, %r14
xorl %esi, %esi
leal 0x1(%rsi), %ebp
movq %r14, %rdi
movl %ebp, %edx
callq 0x8af6
movl %ebp, %esi
cmpl %ebp, %ebx
jne 0x6562
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::random_moves(unsigned int, unsigned int, unsigned int)
void random_moves(unsigned rows, unsigned cols, unsigned n = 0) {
        for( unsigned i = 0; i < n; ++i ) {
            unsigned m = Random::random(4);
            if( m == 0 )
                up(rows, cols);
            else if( m == 1 )
                right(rows, cols);
            else if( m == 2 )
                down(rows, cols);
            else
                left(rows, cols);
        }
    }

// Assembly:
testl %ecx, %ecx
je 0x65ee
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x1fb41(%rip), %r12     # 0x260d8
callq 0x5190
andl $0x3, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8b28
jmp 0x65e2
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8bde
jmp 0x65e2
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8c3c
jmp 0x65e2
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x8b82
decl %ebx
jne 0x6597
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::up(unsigned int, unsigned int)
void up(unsigned rows, unsigned cols) {
        unsigned b = blank();
        if( b >= cols ) {
            unsigned p = b-cols, t = tile(p);
            set_tile(t, b);
            set_blank(p);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
movl (%rdi), %edx
andl $0xf, %edx
movl %edx, %r14d
subl %eax, %r14d
jae 0x8b43
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
leal (,%r14,4), %eax
leal -0x20(%rax), %ecx
xorl %esi, %esi
cmpl $0x8, %r14d
setae %sil
movl 0x4(%rdi,%rsi,4), %esi
movzbl %cl, %ecx
cmovbl %eax, %ecx
shrl %cl, %esi
andl $0xf, %esi
callq 0x8af6
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8ac6
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::right(unsigned int, unsigned int)
void right(unsigned rows, unsigned cols) {
        unsigned b = blank();
        if( b%cols < cols-1 ) {
            unsigned p = b+1, t = tile(p);
            set_tile(t, b);
            set_blank(p);
        }
    }

// Assembly:
movl %edx, %ecx
movl (%rdi), %r8d
andl $0xf, %r8d
movl %r8d, %eax
xorl %edx, %edx
divl %ecx
decl %ecx
cmpl %ecx, %edx
jae 0x8bdd
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal 0x1(%r8), %ebp
leal 0x4(,%r8,4), %eax
leal -0x20(%rax), %ecx
xorl %edx, %edx
cmpl $0x7, %r8d
setae %dl
movl 0x4(%rdi,%rdx,4), %esi
movzbl %cl, %ecx
cmovbl %eax, %ecx
shrl %cl, %esi
andl $0xf, %esi
movl %r8d, %edx
callq 0x8af6
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ac6
retq
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::down(unsigned int, unsigned int)
void down(unsigned rows, unsigned cols) {
        unsigned b = blank();
        if( b+cols < rows*cols ) {
            unsigned p = b+cols, t = tile(p);
            set_tile(t, b);
            set_blank(p);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
movl (%rdi), %edx
andl $0xf, %edx
leal (%rdx,%rax), %r14d
imull %eax, %esi
cmpl %esi, %r14d
jae 0x8c33
movq %rdi, %rbx
leal (,%r14,4), %eax
leal -0x20(%rax), %ecx
xorl %esi, %esi
cmpl $0x8, %r14d
setae %sil
movl 0x4(%rdi,%rsi,4), %esi
movzbl %cl, %ecx
cmovbl %eax, %ecx
shrl %cl, %esi
andl $0xf, %esi
callq 0x8af6
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8ac6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::left(unsigned int, unsigned int)
void left(unsigned rows, unsigned cols) {
        unsigned b = blank();
        if( b%cols > 0 ) {
            unsigned p = b-1,
            t = tile(p);
            set_tile(t, b);
            set_blank(p);
        }
    }

// Assembly:
movl %edx, %ecx
movl (%rdi), %r8d
andl $0xf, %r8d
movl %r8d, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x8c94
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal -0x1(%r8), %ebp
leal -0x4(,%r8,4), %eax
leal -0x20(%rax), %ecx
xorl %edx, %edx
cmpl $0x8, %ebp
setae %dl
movl 0x4(%rdi,%rdx,4), %esi
movzbl %cl, %ecx
cmovbl %eax, %ecx
shrl %cl, %esi
andl $0xf, %esi
movl %r8d, %edx
callq 0x8af6
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ac6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: problem_t::next(state_t const&, int, std::vector<std::pair<state_t, float>, std::allocator<std::pair<state_t, float>>>&) const
virtual void next(const state_t &s, Problem::action_t a, std::vector<std::pair<state_t, float> > &outcomes) const {
        ++expansions_;
        outcomes.clear();
        outcomes.reserve(2);
        if( p_ > 0 ) {
            outcomes.push_back(std::make_pair(s, p_));
            if( a == ::up ) {
                outcomes.back().first.up(rows_, cols_);
            } else if( a == ::right ) {
                outcomes.back().first.right(rows_, cols_);
            } else if( a == ::down ) {
                outcomes.back().first.down(rows_, cols_);
            } else {
                outcomes.back().first.left(rows_, cols_);
            }
        }
        if( 1-p_ > 0 ) {
            outcomes.push_back(std::make_pair(s, 1 - p_));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r15
incq 0x10(%rdi)
movq %rsi, %r14
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x8d26
movq %rax, 0x8(%rbx)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x8e3c
movss 0x20(%r15), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x8d98
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movss %xmm0, 0xc(%rsi)
movq %rbx, %rdi
callq 0x8f34
movq 0x8(%rbx), %rdi
addq $-0x10, %rdi
movl 0x18(%r15), %esi
movl 0x1c(%r15), %edx
cmpl $0x3, %ebp
je 0x8d8c
cmpl $0x2, %ebp
je 0x8d85
testl %ebp, %ebp
jne 0x8d93
callq 0x8b28
jmp 0x8d98
callq 0x8bde
jmp 0x8d98
callq 0x8b82
jmp 0x8d98
callq 0x8c3c
movss 0x20(%r15), %xmm1
movss 0x1d31e(%rip), %xmm0    # 0x260c4
ucomiss %xmm1, %xmm0
jbe 0x8dce
subss %xmm1, %xmm0
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movss %xmm0, 0xc(%rsi)
movq %rbx, %rdi
callq 0x8f34
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::applicable(unsigned int, unsigned int, int) const
bool applicable(unsigned rows, unsigned cols, Problem::action_t a) const {
        switch( a ) {
            case ::up: return blank() >= cols;
            case ::right: return blank() % cols < cols-1;
            case ::down: return blank() + cols < rows*cols;
            case ::left: return blank() % cols > 0;
        }
        return false;
    }

// Assembly:
cmpl $0x3, %ecx
ja 0x8e38
movl %edx, %r8d
movl %ecx, %eax
leaq 0x1d2f9(%rip), %rcx     # 0x260e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rdi), %eax
andl $0xf, %eax
cmpl %r8d, %eax
setae %al
retq
movl (%rdi), %eax
andl $0xf, %eax
addl %r8d, %eax
imull %r8d, %esi
cmpl %esi, %eax
jmp 0x8e24
movl (%rdi), %eax
andl $0xf, %eax
xorl %edx, %edx
divl %r8d
decl %r8d
cmpl %r8d, %edx
setb %al
retq
movl (%rdi), %eax
andl $0xf, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
setne %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::manhattan() const
unsigned manhattan() const {
        unsigned sum = 0;
        for( unsigned p = 0; p < rows()*cols(); ++p )
            if( p != blank() ) {
                unsigned t = tile(p);
                int r = ((1+t)/cols()) - (p/cols()), c = ((1+t)%cols()) - (p%cols());
                sum += (r<0?-r:r) + (c<0?-c:c);
            }
        return sum;
    }

// Assembly:
pushq %r14
pushq %rbx
movl (%rdi), %r10d
movl %r10d, %r11d
shrl $0x4, %r11d
andl $0xf, %r11d
movl %r10d, %ebx
shrl $0x8, %ebx
andl $0xf, %ebx
imull %ebx, %r11d
testl %r11d, %r11d
je 0x91ca
andl $0xf, %r10d
xorl %r14d, %r14d
xorl %esi, %esi
xorl %r8d, %r8d
cmpl %r8d, %r10d
je 0x91bc
leal -0x20(%r14), %ecx
xorl %eax, %eax
cmpl $0x8, %r8d
setae %al
movl 0x4(%rdi,%rax,4), %eax
movzbl %cl, %ecx
cmovbl %r14d, %ecx
shrl %cl, %eax
andl $0xf, %eax
incl %eax
xorl %edx, %edx
divl %ebx
movl %edx, %ecx
movl %eax, %r9d
movl %r8d, %eax
xorl %edx, %edx
divl %ebx
subl %eax, %r9d
subl %edx, %ecx
movl %r9d, %eax
negl %eax
cmovsl %r9d, %eax
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
addl %edx, %esi
addl %eax, %esi
incl %r8d
addl $0x4, %r14d
cmpl %r8d, %r11d
jne 0x916f
jmp 0x91cc
xorl %esi, %esi
movl %esi, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::print(std::ostream&) const
void print(std::ostream &os) const {
        os << "|" << std::setw(2) << blank() << "|";
        for( unsigned i = 0; i < rows() * cols(); ++i ) {
            os << (i == blank() ? 0 : 1+tile(i));
            os << (i < rows() * cols() - 1 ? "," : "|");
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1345d(%rip), %r15     # 0x26be5
movl $0x1, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x5250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movl (%r14), %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0x5160
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl %eax, %edx
shrl $0x8, %edx
testb $0xf, %dl
sete %dl
testb $0xf, %cl
sete %cl
orb %dl, %cl
jne 0x13872
xorl %r12d, %r12d
leaq 0x132eb(%rip), %r13     # 0x26adc
xorl %ebp, %ebp
andl $0xf, %eax
cmpl %eax, %ebp
jne 0x137fe
xorl %esi, %esi
jmp 0x1381e
leal -0x20(%r12), %eax
xorl %ecx, %ecx
cmpl $0x8, %ebp
setae %cl
movl 0x4(%r14,%rcx,4), %esi
movzbl %al, %ecx
cmovbl %r12d, %ecx
shrl %cl, %esi
andl $0xf, %esi
incl %esi
movq %rbx, %rdi
callq 0x5160
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
shrl $0x8, %eax
andl $0xf, %eax
imull %ecx, %eax
decl %eax
cmpl %eax, %ebp
movq %r15, %rsi
cmovbq %r13, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5250
incl %ebp
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movl %eax, %edx
shrl $0x8, %edx
andl $0xf, %edx
imull %ecx, %edx
addl $0x4, %r12d
cmpl %edx, %ebp
jb 0x137f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/typeid.cc
// Function: main
int main()
{
	int arr[10];
	Derived d;
	Base *p = &d;
	
	cout << typeid(42).name() << ", "
	     << typeid(arr).name() << ", "
	     << typeid(Sales_data).name() << ", "
	     << typeid(std::string).name() << ", "
	     << typeid(p).name() << ", "
	     << typeid(*p).name() << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dd6(%rip), %rax      # 0x3fc0
movq 0x8(%rax), %rax
xorl %r14d, %r14d
cmpb $0x2a, (%rax)
sete %r14b
addq %rax, %r14
movq %r14, %rdi
callq 0x1040
movq 0x2dce(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1080
leaq 0xde5(%rip), %r14       # 0x2004
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
leaq 0xdd1(%rip), %rsi       # 0x2007
movl $0x5, %edx
movq %rbx, %rdi
callq 0x1080
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
leaq 0xdb3(%rip), %rsi       # 0x200d
movl $0xc, %edx
movq %rbx, %rdi
callq 0x1080
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
leaq 0xd9c(%rip), %rsi       # 0x201a
movl $0x34, %edx
movq %rbx, %rdi
callq 0x1080
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
leaq 0xdad(%rip), %rsi       # 0x204f
movl $0x6, %edx
movq %rbx, %rdi
callq 0x1080
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
leaq 0xd90(%rip), %rsi       # 0x2056
movl $0x8, %edx
movq %rbx, %rdi
callq 0x1080
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::inifile::dget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string inifile::dget(const std::string& key,
                            const std::string& default_value) const {
    try {
      return this->get(key);
    }
    catch(unknown_entry_error& ex) { /* ignore */ }

    return default_value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x4b734
addq $0x38, %r13
cmpq %r13, %rax
je 0x38529
movq %r12, %rdi
movq %r15, %rsi
callq 0x4b734
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4c4d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xe210
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b634
leaq 0x3ff08(%rip), %rsi     # 0x78450
movq 0x42a71(%rip), %rdx     # 0x7afc0
movq %r12, %rdi
callq 0xe800
movq %rdx, %r13
movq %rax, %r15
movq %r12, %rdi
callq 0xe360
jmp 0x3856d
movq %rdx, %r13
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r13d
jne 0x3859e
callq 0xe1e0
callq 0xe790
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4c4d2
jmp 0x38517
callq 0xe840
nop
// File: /workspace/github_cpp_makefile_star2_O1/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::inifile::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string inifile::get(const std::string& section,
                           const std::string& key) const {
    if(!this->_sections.count(section)) {
      throw unknown_section_error(section);
    }

    if(!this->_sections.find(section)->second.count(key)) {
      throw unknown_entry_error(section, key);
    }

    return this->_sections.find(section)->second.find(key)->second;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4bb18
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x38639
movq %r12, %rdi
movq %r14, %rsi
callq 0x4bb18
movq %rax, %r13
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x4b734
addq $0x48, %r13
cmpq %r13, %rax
je 0x3865a
movq %r12, %rdi
movq %r14, %rsi
callq 0x4bb18
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x4b734
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4c4d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xe210
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4b7f4
leaq 0x3fe10(%rip), %rsi     # 0x78468
jmp 0x3867c
movl $0x10, %edi
callq 0xe210
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4b8f4
leaq 0x3fdd4(%rip), %rsi     # 0x78450
movq 0x4293d(%rip), %rdx     # 0x7afc0
movq %rbx, %rdi
callq 0xe800
jmp 0x3868d
movq %rax, %r14
movq %rbx, %rdi
callq 0xe360
movq %r14, %rdi
callq 0xe840
// File: /workspace/github_cpp_makefile_star2_O1/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::_private::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool _private::split(const std::string& in, const std::string& sep,
                              std::string& first, std::string& second) {
    size_t eqpos = in.find(sep);

    if(eqpos == std::string::npos) {
      return false;
    }

    first = in.substr(0, eqpos);
    second = in.substr(eqpos + sep.size(), in.size() - eqpos - sep.size());

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r12), %rcx
xorl %edx, %edx
callq 0xe820
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x4ad05
movq %r14, -0x30(%rbp)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe4d0
movq %r13, %rdi
movq %r14, %rsi
callq 0xe5c0
movq (%r14), %rdi
leaq -0x40(%rbp), %r13
cmpq %r13, %rdi
je 0x4accb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0xe4b0
movq 0x8(%r12), %rdx
addq %rbx, %rdx
movq 0x8(%r15), %rcx
subq %rdx, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4d0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xe5c0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4ad05
movq -0x40(%rbp), %rsi
incq %rsi
callq 0xe4b0
cmpq $-0x1, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/expression.cpp
// Function: AsynFuncCallContext::ThreadWrapper(void*)
static void * ThreadWrapper(void * arg)
        {
                AsynFuncCallContext * ctx = static_cast<AsynFuncCallContext*>(arg);
                
                int rtn = ctx->FuncNode->Run(ctx->Context);
                delete ctx->Context;
                delete ctx;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0xbe10
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x6561
movq %r14, %rdi
callq 0xc69a
pushq $0x70
popq %rsi
movq %r14, %rdi
callq 0x6270
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: ValueBox::ValueBox(ConstValue*)
ValueBox::ValueBox(ConstValue * value)
{
        this->Value    = NULL; 
        this->RefCount = 1;
        if(value!=NULL)
        {
                this->Value = value->DupValue();
        }
}

// Assembly:
movq $0x0, (%rdi)
movq $0x1, 0x8(%rdi)
testq %rsi, %rsi
je 0x7e27
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: ValueBox::Destroy()
void ValueBox::Destroy()
{
        if(this->RefCount==1)
        {
                delete this;
        }
        else
        {
                this->RefCount--;
        }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x1, %rax
jne 0x7e97
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e82
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6270
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: StringValue::LooksLikeInteger()
bool StringValue::LooksLikeInteger()
{
        char buf[256];
        long value;
        int n = sscanf(this->Value.c_str(), "%ld", &value);
        if(n>0)
        {
                sprintf(buf, "%ld", value);

                if(strlen(buf)==strlen(this->Value.c_str()))
                {
                        return true;
                }
        }
        return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x33785(%rip), %rsi     # 0x3b827
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x6240
testl %eax, %eax
jle 0x80eb
movq 0x8(%rsp), %rdx
leaq 0x33769(%rip), %rsi     # 0x3b827
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x60a0
movq %r14, %rdi
callq 0x6120
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x6120
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r14
je 0x80ed
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: DecimalValue::toString[abi:cxx11]()
string DecimalValue::toString()
{
        char result[1024];
        int prec = mpf_get_prec(this->Value);
        gmp_snprintf (result, sizeof(result), "%.*Ff", prec, this->Value);
        
        char * p = strstr(result, ".");
        if(p==NULL)
        {
            return result;
        }
        
        int len = strlen(p) - 1;
        
        char * q = p + len;
        
        while(*q == '0' && *(q-1)!='.')
        {
            q--;
        }
        
        *(q+1) = '\0';
        
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0x1bf70
leaq 0x2d9e6(%rip), %rdx     # 0x360f8
movq %rsp, %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movl %eax, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x2fe74
movq %r15, %rdi
movl $0x2e, %esi
callq 0x6100
testq %rax, %rax
je 0x8764
movq %rax, %r14
movq %rax, %rdi
callq 0x6120
decl %eax
movslq %eax, %rcx
addq %r14, %rcx
movq %rcx, %rax
cmpb $0x30, (%rcx)
jne 0x8760
leaq -0x1(%rax), %rcx
cmpb $0x2e, -0x1(%rax)
jne 0x874e
movb $0x0, 0x1(%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x6120
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d3c
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: KVValue::toString[abi:cxx11]()
string KVValue::toString()
{
        string ret = "<";
        ret.append(this->Key->toString());
        ret.append(",");
        ret.append(this->Value->GetVal()->toString());
        ret.append(">");
        return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2d772(%rip), %rsi     # 0x36109
leaq 0x2d76c(%rip), %rdx     # 0x3610a
callq 0x7d3c
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x89e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x2d724(%rip), %rsi     # 0x3610b
movq %rbx, %rdi
callq 0x64b0
movq 0x18(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a2a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x2d6dc(%rip), %rsi     # 0x3610d
movq %rbx, %rdi
callq 0x64b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x8a6a
jmp 0x8a7e
jmp 0x8a7b
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8a7e
jmp 0x8a7b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8a91
movq (%r15), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::~MapValue()
MapValue::~MapValue()
{
        map<string, ValueBox*>::iterator i;
        for(i=this->Value.begin();i!=this->Value.end();i++)
        {
                i->second->Destroy();
        }
        this->Value.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3e1ed(%rip), %rax     # 0x46db8
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
leaq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x8bf4
movq 0x40(%r14), %rdi
callq 0x7e66
movq %r14, %rdi
callq 0x61c0
movq %rax, %r14
cmpq %r15, %rax
jne 0x8bdb
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x9c44
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9970
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::AddKV(KVValue*)
void MapValue::AddKV(KVValue * kv)
{
        string key = kv->GetKey()->toString();
        map<string, ValueBox*>::iterator i = this->Value.find(key);

        if(i!=this->Value.end())
        {
                i->second->Destroy();
                this->Value.erase(key);
        }
        this->Value.insert(pair<string, ValueBox*>(key, kv->GetValueBox()->Dup()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9c72
addq $0x18, %r15
cmpq %r15, %rax
je 0x8c7e
movq 0x40(%rax), %rdi
callq 0x7e66
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9cfc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9da4
movq 0x18(%r14), %rdi
callq 0x7ec8
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x99e8
leaq 0x20(%rsp), %rsi
movq %r14, 0x20(%rsi)
movq %rbx, %rdi
callq 0x9a78
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8cd1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8d19
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8d19
jmp 0x8d16
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d34
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6470