LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/StatType.cpp
// Function: Stats::Histogram::add(Stats::Histogram&)
void
Histogram::add(Histogram &hs)
{
    size_type b_size = hs.size();
    assert(size() == b_size);
    assert(min_bucket == hs.min_bucket);

    sum += hs.sum;
    logs += hs.logs;
    squares += hs.squares;
    samples += hs.samples;

    while(bucket_size > hs.bucket_size)
        hs.grow_up();
    while(bucket_size < hs.bucket_size)
        grow_up();

    for (uint32_t i = 0; i < b_size; i++)
        cvec[i] += hs.cvec[i];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
cmpl %ebp, %eax
jne 0xc6175
movsd 0x78(%rbx), %xmm0
ucomisd 0x78(%r14), %xmm0
jne 0xc618e
jp 0xc618e
movupd 0x90(%r14), %xmm0
movupd 0x90(%rbx), %xmm1
addpd %xmm0, %xmm1
movupd 0xa0(%rbx), %xmm0
movupd %xmm1, 0x90(%rbx)
movupd 0xa0(%r14), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0xa0(%rbx)
movsd 0x88(%rbx), %xmm0
movsd 0x88(%r14), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc613f
movq %r14, %rdi
callq 0xc5fd0
jmp 0xc6105
movq %rbx, %rdi
callq 0xc5fd0
movsd 0x88(%rbx), %xmm0
movsd 0x88(%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0xc6126
movq 0xb0(%r14), %rax
movq 0xb0(%rbx), %rcx
movl %ebp, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xc6170
movsd (%rax,%rsi,8), %xmm0
addsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0xc6157
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1df06(%rip), %rdi     # 0xe4082
leaq 0x1de5f(%rip), %rsi     # 0xe3fe2
leaq 0x1df09(%rip), %rcx     # 0xe4093
pushq $0x68
jmp 0xc61a5
leaq 0x1df26(%rip), %rdi     # 0xe40bb
leaq 0x1de46(%rip), %rsi     # 0xe3fe2
leaq 0x1def0(%rip), %rcx     # 0xe4093
pushq $0x69
popq %rdx
callq 0xb210
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/StatType.cpp
// Function: Stats::Histogram::sample(double, int)
void
Histogram::sample(Counter val, int number)
{
    assert(min_bucket < max_bucket);
    if (val < min_bucket) {
        if (min_bucket == 0)
            grow_convert();

        while (val < min_bucket)
            grow_out();
    } else if (val >= max_bucket + bucket_size) {
        if (min_bucket == 0) {
            while (val >= max_bucket + bucket_size)
                grow_up();
        } else {
            while (val >= max_bucket + bucket_size)
                grow_out();
        }
    }

    size_type index =
        (int64_t)std::floor((val - min_bucket) / bucket_size);

    assert(index >= 0 && index < size());
    cvec[index] += number;

    sum += val * number;
    squares += val * val * number;
    logs += log(val) * number;
    samples += number;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd 0x78(%rdi), %xmm2
movsd 0x80(%rdi), %xmm4
ucomisd %xmm2, %xmm4
jbe 0xc6278
movl %esi, %ebp
movq %rdi, %rbx
ucomisd %xmm0, %xmm2
movsd %xmm0, (%rsp)
jbe 0xc61fc
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0xc629a
jp 0xc629a
movq %rbx, %rdi
callq 0xc5f30
jmp 0xc6295
movsd 0x88(%rbx), %xmm1
movapd %xmm4, %xmm3
addsd %xmm1, %xmm3
ucomisd %xmm3, %xmm0
jb 0xc62b7
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0xc626c
jp 0xc626c
addsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
jb 0xc62b7
movq %rbx, %rdi
callq 0xc5fd0
movsd (%rsp), %xmm0
movsd 0x80(%rbx), %xmm4
movsd 0x88(%rbx), %xmm1
jmp 0xc6222
movq %rbx, %rdi
callq 0xc5dda
movsd (%rsp), %xmm0
movsd 0x80(%rbx), %xmm4
movsd 0x88(%rbx), %xmm1
addsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
jae 0xc624f
jmp 0xc62b7
leaq 0x1de58(%rip), %rdi     # 0xe40d7
leaq 0x1dd5c(%rip), %rsi     # 0xe3fe2
leaq 0x1de62(%rip), %rcx     # 0xe40ef
pushq $0x7c
popq %rdx
callq 0xb210
movsd (%rsp), %xmm0
movsd 0x78(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc62af
movq %rbx, %rdi
callq 0xc5dda
jmp 0xc6295
movsd 0x88(%rbx), %xmm1
subsd 0x78(%rbx), %xmm0
divsd %xmm1, %xmm0
callq 0xb490
cvttsd2si %xmm0, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
cmpl %r14d, %eax
jbe 0xc636f
cvtsi2sd %ebp, %xmm2
movsd %xmm2, 0x8(%rsp)
movl %r14d, %eax
movq 0xb0(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd (%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm2, %xmm1
addsd 0x90(%rbx), %xmm1
movsd %xmm1, 0x90(%rbx)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
addsd 0xa0(%rbx), %xmm1
movsd %xmm1, 0xa0(%rbx)
callq 0xb260
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x98(%rbx), %xmm0
movsd %xmm0, 0x98(%rbx)
addsd 0xa8(%rbx), %xmm1
movsd %xmm1, 0xa8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc9a7(%rip), %rdi      # 0xd2d1d
leaq 0x1dc65(%rip), %rsi     # 0xe3fe2
leaq 0x1dd6b(%rip), %rcx     # 0xe40ef
movl $0x90, %edx
callq 0xb210
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/TLDRAM.cpp
// Function: ramulator::TLDRAM::init_rowhit()
void TLDRAM::init_rowhit()
{
    // RD
    rowhit[int(Level::Bank)][int(Command::RD)] = [] (DRAM<TLDRAM>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened):
                if (node->row_state.find(id) != node->row_state.end())
                    return true;
                return false;
            default: assert(false);
        }};

    // WR
    rowhit[int(Level::Bank)][int(Command::WR)] = rowhit[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x11d8(%rdi), %r14
movups 0x11d8(%rdi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x11d8(%rbx)
movups 0x11e8(%rbx), %xmm0
leaq 0x2450(%rip), %rax      # 0xc9350
movq %rax, 0x11e8(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x23da(%rip), %rax      # 0xc92ec
movq %rax, 0x11f0(%rbx)
callq 0x96b6a
addq $0x11f8, %rbx           # imm = 0x11F8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc99da
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/TLDRAM.cpp
// Function: ramulator::TLDRAM::init_rowopen()
void TLDRAM::init_rowopen()
{
    // RD
    rowopen[int(Level::Bank)][int(Command::RD)] = [] (DRAM<TLDRAM>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened): return true;
            default: assert(false);
        }};

    // WR
    rowopen[int(Level::Bank)][int(Command::WR)] = rowopen[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1c78(%rdi), %r14
movups 0x1c78(%rdi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c78(%rbx)
movups 0x1c88(%rbx), %xmm0
leaq 0x2432(%rip), %rax      # 0xc93a0
movq %rax, 0x1c88(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x23e8(%rip), %rax      # 0xc9368
movq %rax, 0x1c90(%rbx)
callq 0x96b6a
addq $0x1c98, %rbx           # imm = 0x1C98
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc99da
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/WideIO.cpp
// Function: ramulator::WideIO::init_speed()
void WideIO::init_speed()
{
    const static int RFC_TABLE[int(Speed::MAX)][int(Org::MAX)] = {
        {18, 26, 26, 42},
        {24, 35, 35, 56}
    };
    const static int REFI_TABLE[int(Speed::MAX)][int(Org::MAX)] = {
        {3120, 1560, 780, 780},
        {4160, 2080, 1040, 520}
    };
    int speed = 0, density = 0;
    switch(speed_entry.rate){
        case 200: speed = 0; break;
        case 266: speed = 1; break;
        default: assert(false);
    }
    switch(org_entry.size >> 8){
        case 1: density = 0; break;
        case 2: density = 1; break;
        case 4: density = 2; break;
        case 8: density = 3; break;
        default: assert(false);
    }
    speed_entry.nRFC = RFC_TABLE[speed][density];
    speed_entry.nREFI = REFI_TABLE[speed][density];
}

// Assembly:
pushq %rax
movl 0x26f8(%rdi), %eax
cmpl $0xc8, %eax
je 0xcae02
cmpl $0x10a, %eax            # imm = 0x10A
jne 0xcae6f
pushq $0x1
popq %rax
jmp 0xcae04
xorl %eax, %eax
movl 0x25f0(%rdi), %ecx
sarl $0x8, %ecx
decl %ecx
cmpl $0x8, %ecx
jae 0xcae56
movl $0x8b, %edx
btl %ecx, %edx
jae 0xcae56
movl %ecx, %ecx
leaq 0x1ab99(%rip), %rdx     # 0xe59c0
movq (%rdx,%rcx,8), %rcx
shll $0x4, %eax
leaq 0x1abcb(%rip), %rdx     # 0xe5a00
addq %rax, %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, 0x274c(%rdi)
leaq 0x1abd8(%rip), %rdx     # 0xe5a20
addq %rax, %rdx
movl (%rdx,%rcx,4), %eax
movl %eax, 0x2750(%rdi)
popq %rax
retq
leaq 0x64fc(%rip), %rdi      # 0xd1359
leaq 0x1a4be(%rip), %rsi     # 0xe5322
leaq 0x1a556(%rip), %rcx     # 0xe53c1
pushq $0x4a
jmp 0xcae86
leaq 0x64e3(%rip), %rdi      # 0xd1359
leaq 0x1a4a5(%rip), %rsi     # 0xe5322
leaq 0x1a53d(%rip), %rcx     # 0xe53c1
pushq $0x43
popq %rdx
callq 0xb210
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]ramulator/src/WideIO2.cpp
// Function: ramulator::WideIO2::init_rowopen()
void WideIO2::init_rowopen()
{
    // RD
    rowopen[int(Level::Bank)][int(Command::RD)] = [] (DRAM<WideIO2>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened): return true;
            default: assert(false);
        }};

    // WR
    rowopen[int(Level::Bank)][int(Command::WR)] = rowopen[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x15e0(%rdi), %r14
movups 0x15e0(%rdi), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x15e0(%rbx)
movups 0x15f0(%rbx), %xmm0
leaq 0x2b2(%rip), %rax       # 0xcf59a
movq %rax, 0x15f0(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0x268(%rip), %rax       # 0xcf562
movq %rax, 0x15f8(%rbx)
callq 0x96b6a
addq $0x1600, %rbx           # imm = 0x1600
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcf9bc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r13
movq %r14, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
movq 0x70(%rbx), %rsi
movl $0x84, %edx
movq %r13, %rdi
callq 0x20e0
movl 0x4(%rsp), %eax
cmpl $0x1, %eax
je 0x2735
testl %eax, %eax
jne 0x275f
leaq 0x19ef(%rip), %rdi      # 0x40aa
xorl %eax, %eax
callq 0x2f37
pushq $0x28
popq %rdi
callq 0x2150
movq %r12, %rbp
movq %r15, %r12
movq %r13, %r15
movq %rax, %r13
addq $0x10, %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r13)
andq $0x0, 0x20(%r13)
movq %rax, (%r13)
andq $0x0, 0x8(%r13)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
pushq $0x28
popq %rdx
movq %r13, %rcx
pushq $-0x1
popq %r8
xorl %eax, %eax
callq 0x2200
movq (%r13), %rcx
movl 0x20(%r13), %r8d
movsbl 0x24(%r13), %r9d
movq %r15, %r13
movq %r12, %r15
movq %rbp, %r12
pushq $0x7
popq %rdi
pushq $0x2
popq %rsi
leaq 0x19e1(%rip), %rdx      # 0x410d
xorl %eax, %eax
callq 0x318d
jmp 0x275f
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
movq %rsp, %rcx
pushq $-0x1
popq %r8
xorl %eax, %eax
callq 0x2200
movl (%rsp), %esi
leaq 0x198b(%rip), %rdi      # 0x40e3
xorl %eax, %eax
callq 0x2f37
movq %r12, %rdi
callq 0x28c2
movq %r14, %rdi
callq 0x20d0
jmp 0x267b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14(%rsp), %rbp
pushq $-0x1
popq %r13
movq %r14, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
movq 0x70(%rbx), %rsi
movl $0x84, %edx
movq %rbp, %rdi
callq 0x20e0
movl 0x14(%rsp), %eax
cmpl $0x3, %eax
je 0x2881
cmpl $0x2, %eax
jne 0x28ad
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
pushq $0x8
popq %rdx
leaq 0x8(%rsp), %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x2200
movsd 0x8(%rsp), %xmm0
leaq 0x18b8(%rip), %rdi      # 0x4130
movb $0x1, %al
callq 0x2e1c
jmp 0x28ad
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
pushq $0x4
popq %rdx
leaq 0x4(%rsp), %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x2200
movl 0x4(%rsp), %esi
leaq 0x18bb(%rip), %rdi      # 0x4161
xorl %eax, %eax
callq 0x2e1c
movq %r12, %rdi
callq 0x28c2
movq %r14, %rdi
callq 0x20d0
jmp 0x281f
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
leaq 0x90(%rdi), %r15
leaq 0xc(%rdi), %rax
movq %rax, 0xa8(%rsp)
pushq $-0x1
popq %r13
pushq $0x11
popq %r12
movq %r15, 0xa0(%rsp)
movq %r14, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
je 0x2ac9
testl %eax, %eax
jne 0x2b89
callq 0x2986
andw $0x0, 0xb0(%rsp)
andl $0x0, 0xb4(%rsp)
pushq $0x28
popq %r15
movq %r15, %rdi
callq 0x2150
movq %r12, %rbp
movl %r13d, %r12d
movq %rax, %r13
addq $0x10, %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r13)
andq $0x0, 0x20(%r13)
movq %rax, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, %rdi
leaq 0x1763(%rip), %rsi      # 0x41e9
callq 0x2220
movl $0x1b, 0x20(%r13)
movb $0x6d, 0x24(%r13)
movq %rbx, %rdi
leaq 0xb8(%rsp), %rsi
movq %r15, %rdx
movq 0xa0(%rsp), %r15
movq %r13, %rcx
movl %r12d, %r13d
movq %rbp, %r12
movl %r13d, %r8d
xorl %eax, %eax
callq 0x21d0
movq %rbp, %rcx
jmp 0x2b73
orl $-0x1, (%rsp)
movq %rbx, %rdi
movq 0xa8(%rsp), %rsi
pushq $0x4
popq %rbp
movq %rbp, %rdx
leaq 0x9c(%rsp), %rcx
movq %rbp, %r8
leaq 0x98(%rsp), %r9
xorl %eax, %eax
callq 0x21f0
movl 0x9c(%rsp), %esi
movl 0x98(%rsp), %edx
callq 0x29a4
movl %eax, 0x94(%rsp)
movq 0x34bf(%rip), %rdi      # 0x5fd8
leaq 0x16d4(%rip), %rsi      # 0x41f4
callq 0x2140
movl 0x94(%rsp), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2090
andw $0x0, 0xb0(%rsp)
movl $0x1, 0xb4(%rsp)
movq %rbx, %rdi
leaq 0xb8(%rsp), %rsi
movq %rbp, %rdx
leaq 0x94(%rsp), %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x21d0
movq %r12, %rcx
movq %rsp, %rdi
leaq 0xb0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x20d0
jmp 0x2a10
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
leaq 0x90(%rdi), %r15
leaq 0xc(%rdi), %r12
pushq $0x4
popq %rbp
pushq $0x8
popq %r13
movq %r14, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
movl 0x8(%rbx), %eax
cmpl $0x3, %eax
je 0x2d52
cmpl $0x2, %eax
jne 0x2e0c
orl $-0x1, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x98(%rsp), %rcx
movq %r13, %r8
leaq 0x90(%rsp), %r9
xorl %eax, %eax
callq 0x21f0
movsd 0x98(%rsp), %xmm0
movsd 0x90(%rsp), %xmm1
callq 0x2bfc
movsd %xmm0, 0x88(%rsp)
movw $0x1, 0xa0(%rsp)
movl $0x2, 0xa4(%rsp)
movq %rbx, %rdi
leaq 0xa8(%rsp), %rsi
movq %r13, %rdx
jmp 0x2de0
orl $-0x1, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
leaq 0x98(%rsp), %rcx
movq %rbp, %r8
leaq 0x90(%rsp), %r9
xorl %eax, %eax
callq 0x21f0
movl 0x98(%rsp), %esi
movl 0x90(%rsp), %edx
callq 0x2c64
movl %eax, 0x88(%rsp)
movq 0x323e(%rip), %rdi      # 0x5fd8
leaq 0x14a8(%rip), %rsi      # 0x4249
callq 0x2140
movl 0x88(%rsp), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2090
movw $0x1, 0xa0(%rsp)
movl $0x3, 0xa4(%rsp)
movq %rbx, %rdi
leaq 0xa8(%rsp), %rsi
movq %rbp, %rdx
leaq 0x88(%rsp), %rcx
pushq $-0x1
popq %r8
xorl %eax, %eax
callq 0x21d0
pushq $0x11
popq %rcx
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x20d0
jmp 0x2cbf
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e89
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)
pushq $0x1
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x2110
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 0x13b6(%rip), %rdx      # 0x427d
leaq 0xe0(%rsp), %r14
pushq $0x22
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21b0
leaq 0x101(%rsp), %rdi
movl $0x3de, %esi            # imm = 0x3DE
movq %rbx, %rdx
movq %r15, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0x2080
decl %eax
cltq
cmpb $0xa, 0xe0(%rsp,%rax)
jne 0x2f12
movb $0x0, 0xe0(%rsp,%rax)
leaq 0x1380(%rip), %rdi      # 0x4299
leaq 0xe0(%rsp), %rsi
xorl %eax, %eax
callq 0x2030
addq $0x4e8, %rsp            # imm = 0x4E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fa4
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)
pushq $0x1
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x2110
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 0x12bf(%rip), %rdx      # 0x42a1
leaq 0xe0(%rsp), %r14
pushq $0x22
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x21b0
leaq 0x101(%rsp), %rdi
movl $0x3de, %esi            # imm = 0x3DE
movq %rbx, %rdx
movq %r15, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0x2080
decl %eax
cltq
cmpb $0xa, 0xe0(%rsp,%rax)
jne 0x302d
movb $0x0, 0xe0(%rsp,%rax)
leaq 0x1265(%rip), %rdi      # 0x4299
leaq 0xe0(%rsp), %rsi
xorl %eax, %eax
callq 0x2030
addq $0x4e8, %rsp            # imm = 0x4E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
movq %rdx, 0x18(%rsp)
movl %esi, %ebp
movl %edi, %r13d
leaq 0x50(%rsp), %r12
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x3200
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %rsi
movl %ebx, %edi
callq 0x2110
xorl %eax, %eax
leaq 0x14(%rsp), %r14
movb %al, 0x2(%r14)
andw $0x0, (%r14)
leaq 0x10(%rsp), %r15
movb %al, 0x2(%r15)
andw $0x0, (%r15)
movl %ebp, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x316d
movl %r13d, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0x316d
leaq 0x30(%rsp), %rbx
movq %r12, 0x10(%rbx)
leaq 0x540(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rbx)
leaq 0x20(%rsp), %rax
movq (%rax), %r9
movq 0x8(%rax), %rax
movq %rax, (%rsp)
leaq 0x105a(%rip), %rdx      # 0x42d9
leaq 0x100(%rsp), %r12
pushq $0x1e
popq %rsi
movq %r12, %rdi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x21b0
leaq 0x11d(%rsp), %rdi
movl $0x3e2, %esi            # imm = 0x3E2
movq 0x18(%rsp), %rdx
movq %rbx, %rcx
callq 0x20a0
movq %r12, %rdi
callq 0x2080
decl %eax
cltq
cmpb $0xa, 0x100(%rsp,%rax)
jne 0x32d2
movb $0x0, 0x100(%rsp,%rax)
leaq 0xfc0(%rip), %rdi       # 0x4299
leaq 0x100(%rsp), %rsi
xorl %eax, %eax
callq 0x2030
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xe8, %rsp
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x2526
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
pushq $0x8
popq %rdi
callq 0x2100
movq %rax, %r14
andq $0x0, (%rax)
pushq $0x10
popq %rdi
callq 0x2100
leaq 0x2a09(%rip), %rcx      # 0x4d48
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x20e0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2368
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x2886
pushq $0x8
popq %rdi
callq 0x2100
movq %rax, %r14
andq $0x0, (%rax)
pushq $0x10
popq %rdi
callq 0x2100
leaq 0x29f0(%rip), %rcx      # 0x4d88
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x20e0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23c1
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x2886
leaq 0x10(%rsp), %rdi
callq 0x2550
leaq 0x10(%rsp), %rdi
callq 0x257c
leaq 0x38(%rsp), %rdi
callq 0x25cc
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2402
jmp 0x2417
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x241a
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x241a
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2110
jmp 0x242a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x257c
leaq 0x38(%rsp), %rdi
callq 0x25cc
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2956
leaq 0x80(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x296c
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a10
movl $0x1, 0x50(%rbx)
movq %r14, %rdi
callq 0x2180
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2994
andl $0x0, 0x50(%rbx)
movq %r14, %rdi
callq 0x2180
leaq 0x10(%rsp), %rdi
callq 0x29bc
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x29bc
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2956
leaq 0x80(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2e2a
movq 0x10(%rbx), %rax
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x2e52
movl $0x2, 0x50(%rbx)
movq %r14, %rdi
callq 0x2180
leaq 0x8(%rsp), %rdi
callq 0x29bc
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x29bc
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x4(%rdi)
movl %edx, %ebp
movl %esi, %r15d
movl %esi, %eax
shll $0x4, %eax
movl %edx, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, (%rdi)
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x76dc
imull %r15d, %ebp
cmpl %r14d, %ebp
je 0x5eec
leal 0x1(%r14), %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x76ee
movl %r15d, %r14d
jmp 0x5ed0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x1610b(%rip), %r12     # 0x1c01c
subl $0x1, %ebx
jb 0x5f63
callq 0x51a0
andl $0x3, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x7756
jmp 0x5f11
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x780c
jmp 0x5f11
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x786a
jmp 0x5f11
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x77b0
jmp 0x5f11
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7771
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 0x76ee
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x780b
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 0x76ee
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x76dc
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7861
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 0x76ee
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x78c2
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 0x76ee
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x76dc
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x794a
movq %rax, 0x8(%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7a70
movss 0x20(%r15), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x79c0
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 0x7bba
movq 0x8(%rbx), %rdi
addq $-0x10, %rdi
movl 0x18(%r15), %esi
movl 0x1c(%r15), %edx
cmpl $0x3, %ebp
je 0x79ae
cmpl $0x2, %ebp
je 0x79a7
testl %ebp, %ebp
jne 0x79b5
callq 0x7756
jmp 0x79ba
callq 0x780c
jmp 0x79ba
callq 0x77b0
jmp 0x79ba
callq 0x786a
movss 0x20(%r15), %xmm0
ucomiss 0x14641(%rip), %xmm0    # 0x1c008
jae 0x79f4
movss 0x14637(%rip), %xmm1    # 0x1c008
subss %xmm0, %xmm1
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsi)
movss %xmm1, 0xc(%rsi)
movq %rbx, %rdi
callq 0x7bba
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movl (%rdi), %esi
movl %esi, %r8d
shrl $0x4, %r8d
andl $0xf, %r8d
movl %esi, %r9d
shrl $0x8, %r9d
andl $0xf, %r9d
imull %r9d, %r8d
andl $0xf, %esi
xorl %r10d, %r10d
movl $0xffffffe0, %r11d      # imm = 0xFFFFFFE0
movl $0xff, %r14d
xorl %edx, %edx
cmpl %r10d, %r8d
je 0x7e30
cmpl %r10d, %esi
je 0x7e27
leal 0x20(%r11), %eax
xorl %ecx, %ecx
cmpl $0x8, %r10d
setae %cl
movl 0x4(%rdi,%rcx,4), %ebp
movzbl %al, %ecx
cmovael %r11d, %ecx
shrl %cl, %ebp
andb $0xf, %bpl
incb %bpl
movzbl %bpl, %eax
divb %r9b
movl %eax, %ecx
movzbl %ah, %ebp
movzbl %r10b, %eax
divb %r9b
movzbl %ah, %ebx
movzbl %cl, %ecx
movzbl %al, %eax
subl %eax, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
andl %r14d, %eax
subl %ebx, %ebp
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
andl %r14d, %ecx
addl %ecx, %edx
addl %eax, %edx
incl %r10d
addl $0x4, %r11d
jmp 0x7dc4
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd92b(%rip), %r15      # 0x1cbbd
movq %rsi, %rdi
movq %r15, %rsi
callq 0x5230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl (%r14), %esi
andl $0xf, %esi
movq %rax, %rdi
callq 0x5160
movq %rax, %rdi
movq %r15, %rsi
callq 0x5230
xorl %r12d, %r12d
leaq 0xd7e4(%rip), %r13      # 0x1cab4
xorl %ebp, %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
cmpl %edx, %ebp
jae 0xf34e
andl $0xf, %eax
cmpl %eax, %ebp
jne 0xf2f7
xorl %esi, %esi
jmp 0xf317
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
movq %rbx, %rdi
callq 0x5230
incl %ebp
addl $0x4, %r12d
jmp 0xf2d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq 0x2e07(%rip), %rax      # 0x3fc0
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
movq 0x2e08(%rip), %rdi      # 0x3fd8
callq 0x1050
leaq 0xe28(%rip), %rbx       # 0x2004
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
leaq 0xe19(%rip), %rsi       # 0x2007
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
leaq 0xe05(%rip), %rsi       # 0x200d
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
leaq 0xdf8(%rip), %rsi       # 0x201a
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
leaq 0xe13(%rip), %rsi       # 0x204f
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
leaq 0xe00(%rip), %rsi       # 0x2056
movq %rax, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
callq 0x30980
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xf210
callq 0xf800
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf6d0
jmp 0x30b1a
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x42d98
testq %rax, %rax
je 0x30da8
movq %r12, %rdi
movq %rbx, %rsi
callq 0x42f38
leaq 0x40(%rax), %rdi
movq %r14, %rsi
callq 0x42c40
testq %rax, %rax
je 0x30dc7
movq %r12, %rdi
movq %rbx, %rsi
callq 0x42f38
leaq 0x40(%rax), %rdi
movq %r14, %rsi
callq 0x42cee
leaq 0x40(%rax), %rsi
movq %r15, %rdi
callq 0xf6d0
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xf250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42dbc
leaq 0x46513(%rip), %rsi     # 0x772d8
jmp 0x30de7
pushq $0x10
popq %rdi
callq 0xf250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x42e46
leaq 0x464d9(%rip), %rsi     # 0x772c0
movq 0x491ca(%rip), %rdx     # 0x79fb8
movq %r15, %rdi
callq 0xf850
jmp 0x30df8
movq %rax, %rbx
movq %r15, %rdi
callq 0xf3c0
movq %rbx, %rdi
callq 0xf880
// File: /workspace/github_cpp_makefile_star2_O2/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::_private::trim(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&)
inline std::string _private::trim(const std::string& str,
                                    const std::string& whitespace) {
    size_t startpos = str.find_first_not_of(whitespace);
    size_t endpos = str.find_last_not_of(whitespace);

    // only whitespace, return empty line
    if(startpos == std::string::npos || endpos == std::string::npos) {
      return std::string();
    }

    // trim leading and trailing whitespace
    return str.substr(startpos, endpos - startpos + 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0xf440
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xf920
cmpq $-0x1, %r15
setne %cl
cmpq $-0x1, %rax
setne %dl
testb %dl, %cl
jne 0x4212c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x42143
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xf540
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
xorl %edx, %edx
callq 0xf9b0
movq %rax, %r14
cmpq $-0x1, %rax
je 0x4225f
movq %rbx, -0x30(%rbp)
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xf540
movq %r13, %rdi
movq %rbx, %rsi
callq 0xf620
movq %rbx, %rdi
callq 0xf9c8
movq 0x8(%r12), %rdx
addq %r14, %rdx
movq 0x8(%r15), %rcx
subq %rdx, %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf540
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xf620
movq %rbx, %rdi
callq 0xf9c8
cmpq $-0x1, %r14
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_O2/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:
andq $0x0, (%rdi)
movq $0x1, 0x8(%rdi)
testq %rsi, %rsi
je 0x6cf0
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6d38
movq %rbx, %rdi
callq 0x6cf8
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x6270
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop