LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]ramulator/src/StatType.cpp
// Function: Stats::Histogram::grow_convert()
void
Histogram::grow_convert()
{
    int size = cvec.size();
    int half = (size + 1) / 2; // round up!
    //bool even = (size & 1) == 0;

    int pair = size - 1;
    for (int i = size - 1; i >= half; --i) {
        cvec[i] = cvec[pair];
        if (pair - 1 >= 0)
            cvec[i] += cvec[pair - 1];
        pair -= 2;
    }

    for (int i = half - 1; i >= 0; i--)
        cvec[i] = Counter();

    min_bucket = -max_bucket;// - (even ? bucket_size : 0);
    bucket_size *= 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xb0, %rdi
callq 0x1fabe0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x2253f1
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2e5e0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2e5e0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jl 0x2253da
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2e5e0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2e5e0
movsd -0x38(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x225346
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x225426
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2e5e0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2253fa
movq -0x28(%rbp), %rax
movsd 0x80(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x78(%rax)
movsd 0x3e41a(%rip), %xmm0    # 0x263870
mulsd 0x88(%rax), %xmm0
movsd %xmm0, 0x88(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.cpp
// Function: Stats::Histogram::grow_up()
void
Histogram::grow_up()
{
    int size = cvec.size();
    int half = (size + 1) / 2; // round up!

    int pair = 0;
    for (int i = 0; i < half; i++) {
        cvec[i] = cvec[pair];
        if (pair + 1 < size)
            cvec[i] += cvec[pair + 1];
        pair += 2;
    }
    assert(pair == size || pair == size + 1);

    for (int i = half; i < size; i++)
        cvec[i] = Counter();

    max_bucket *= 2;
    bucket_size *= 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xb0, %rdi
callq 0x1fabe0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x22555d
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2e5e0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2e5e0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0x225546
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2e5e0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2e5e0
movsd -0x38(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2254b2
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x39(%rbp)
je 0x22557b
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x225584
jmp 0x225586
jmp 0x2255a5
leaq 0x3e37b(%rip), %rdi     # 0x263908
leaq 0x3e316(%rip), %rsi     # 0x2638aa
movl $0x5b, %edx
leaq 0x3e389(%rip), %rcx     # 0x263929
callq 0xc280
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2255d9
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2e5e0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2255ab
movq -0x28(%rbp), %rax
movsd 0x3e28b(%rip), %xmm0    # 0x263870
mulsd 0x80(%rax), %xmm0
movsd %xmm0, 0x80(%rax)
movsd 0x3e273(%rip), %xmm0    # 0x263870
mulsd 0x88(%rax), %xmm0
movsd %xmm0, 0x88(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
cmpl -0x14(%rbp), %eax
jne 0x225656
jmp 0x225675
leaq 0x3e2ed(%rip), %rdi     # 0x26394a
leaq 0x3e246(%rip), %rsi     # 0x2638aa
movl $0x68, %edx
leaq 0x3e2eb(%rip), %rcx     # 0x26395b
callq 0xc280
movq -0x20(%rbp), %rax
movsd 0x78(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x78(%rax), %xmm0
jne 0x22568d
jp 0x22568d
jmp 0x2256ac
leaq 0x3e2ef(%rip), %rdi     # 0x263983
leaq 0x3e20f(%rip), %rsi     # 0x2638aa
movl $0x69, %edx
leaq 0x3e2b4(%rip), %rcx     # 0x26395b
callq 0xc280
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x90(%rcx), %xmm0
addsd 0x90(%rax), %xmm0
movsd %xmm0, 0x90(%rax)
movq -0x10(%rbp), %rcx
movsd 0x98(%rcx), %xmm0
addsd 0x98(%rax), %xmm0
movsd %xmm0, 0x98(%rax)
movq -0x10(%rbp), %rcx
movsd 0xa0(%rcx), %xmm0
addsd 0xa0(%rax), %xmm0
movsd %xmm0, 0xa0(%rax)
movq -0x10(%rbp), %rcx
movsd 0xa8(%rcx), %xmm0
addsd 0xa8(%rax), %xmm0
movsd %xmm0, 0xa8(%rax)
movq -0x20(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x88(%rax), %xmm0
jbe 0x225745
movq -0x10(%rbp), %rdi
callq 0x225470
jmp 0x225720
jmp 0x225747
movq -0x20(%rbp), %rax
movsd 0x88(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x88(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x225770
movq -0x20(%rbp), %rdi
callq 0x225470
jmp 0x225747
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2257ca
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0xb0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movsd -0x28(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x225777
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl 0x26f8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xc8, %eax
je 0x237020
jmp 0x237014
movl -0x14(%rbp), %eax
subl $0x10a, %eax            # imm = 0x10A
je 0x237029
jmp 0x237032
movl $0x0, -0xc(%rbp)
jmp 0x237051
movl $0x1, -0xc(%rbp)
jmp 0x237051
leaq 0x18b28(%rip), %rdi     # 0x24fb61
leaq 0x2e3f7(%rip), %rsi     # 0x265437
movl $0x43, %edx
leaq 0x2e4ac(%rip), %rcx     # 0x2654f8
callq 0xc280
movq -0x20(%rbp), %rax
movl 0x25f0(%rax), %eax
sarl $0x8, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x2370a3
movq -0x28(%rbp), %rax
leaq 0x2dc7a(%rip), %rcx     # 0x264cf0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x10(%rbp)
jmp 0x2370c2
movl $0x1, -0x10(%rbp)
jmp 0x2370c2
movl $0x2, -0x10(%rbp)
jmp 0x2370c2
movl $0x3, -0x10(%rbp)
jmp 0x2370c2
leaq 0x18ab7(%rip), %rdi     # 0x24fb61
leaq 0x2e386(%rip), %rsi     # 0x265437
movl $0x4a, %edx
leaq 0x2e43b(%rip), %rcx     # 0x2654f8
callq 0xc280
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x2df4f(%rip), %rcx     # 0x265020
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x274c(%rax)
movslq -0xc(%rbp), %rdx
leaq 0x2df50(%rip), %rcx     # 0x265040
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x2750(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x21e0
movq -0xb8(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x21f0
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x2c80
movq %rax, %rsi
leaq -0x8c(%rbp), %rdi
movl $0x84, %edx
callq 0x2110
movl -0x8c(%rbp), %eax
movl %eax, -0xac(%rbp)
testl %eax, %eax
je 0x28f2
jmp 0x28de
movl -0xac(%rbp), %eax
subl $0x1, %eax
je 0x29a3
jmp 0x29e2
movq -0xa8(%rbp), %rdi
callq 0x2810
movl $0x28, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, -0xc0(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x20c0
movq -0xc0(%rbp), %rdi
callq 0x2ca0
movq -0xc0(%rbp), %rax
movq -0xa8(%rbp), %rdi
movq %rax, -0x98(%rbp)
leaq -0x8c(%rbp), %rsi
addq $0x4, %rsi
movq -0x98(%rbp), %rcx
movl $0x28, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x2250
movq -0x98(%rbp), %rdi
callq 0x2080
movq %rax, %rcx
movq -0x98(%rbp), %rax
movl 0x20(%rax), %r8d
movq -0x98(%rbp), %rax
movsbl 0x24(%rax), %r9d
movl $0x7, %edi
movl $0x2, %esi
leaq 0x176d(%rip), %rdx      # 0x4107
movb $0x0, %al
callq 0x3cb0
jmp 0x29e4
movq -0xa8(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
addq $0x4, %rsi
movl $0x4, %edx
leaq -0x9c(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x2250
movq -0xa8(%rbp), %rdi
movl -0x9c(%rbp), %esi
callq 0x2830
jmp 0x29e4
jmp 0x29e4
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x2cc0
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
callq 0x2100
jmp 0x287a
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x21e0
movq -0xb8(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x21f0
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x2c80
movq %rax, %rsi
leaq -0x8c(%rbp), %rdi
movl $0x84, %edx
callq 0x2110
movl -0x8c(%rbp), %eax
movl %eax, -0xac(%rbp)
subl $0x2, %eax
je 0x2bcf
jmp 0x2bbf
movl -0xac(%rbp), %eax
subl $0x3, %eax
je 0x2c10
jmp 0x2c4f
movq -0xa8(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
addq $0x4, %rsi
movl $0x8, %edx
leaq -0x98(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x2250
movq -0xa8(%rbp), %rdi
movsd -0x98(%rbp), %xmm0
callq 0x2ae0
jmp 0x2c51
movq -0xa8(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
addq $0x4, %rsi
movl $0x4, %edx
leaq -0x9c(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x2250
movq -0xa8(%rbp), %rdi
movl -0x9c(%rbp), %esi
callq 0x2b10
jmp 0x2c51
jmp 0x2c51
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x2cc0
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
callq 0x2100
jmp 0x2b5a
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
testb %al, %al
je 0x3857
movaps %xmm0, -0x4d0(%rbp)
movaps %xmm1, -0x4c0(%rbp)
movaps %xmm2, -0x4b0(%rbp)
movaps %xmm3, -0x4a0(%rbp)
movaps %xmm4, -0x490(%rbp)
movaps %xmm5, -0x480(%rbp)
movaps %xmm6, -0x470(%rbp)
movaps %xmm7, -0x460(%rbp)
movq %r9, -0x4d8(%rbp)
movq %r8, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movq %rdx, -0x4f0(%rbp)
movq %rsi, -0x4f8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
leaq -0x18(%rbp), %rsi
callq 0x2140
leaq -0x440(%rbp), %rax
leaq -0x500(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x22, %esi
leaq 0x9ca(%rip), %rdx       # 0x4298
movb $0x0, %al
callq 0x2210
leaq -0x420(%rbp), %rdi
addq $0x21, %rdi
movq -0x8(%rbp), %rdx
leaq -0x440(%rbp), %rcx
movl $0x3de, %esi            # imm = 0x3DE
callq 0x20d0
leaq -0x440(%rbp), %rax
leaq -0x420(%rbp), %rdi
callq 0x20b0
movl %eax, -0x444(%rbp)
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x420(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x3939
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x420(%rbp,%rax)
leaq 0x974(%rip), %rdi       # 0x42b4
xorl %eax, %eax
leaq -0x420(%rbp), %rsi
callq 0x2030
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
testb %al, %al
je 0x39a7
movaps %xmm0, -0x4d0(%rbp)
movaps %xmm1, -0x4c0(%rbp)
movaps %xmm2, -0x4b0(%rbp)
movaps %xmm3, -0x4a0(%rbp)
movaps %xmm4, -0x490(%rbp)
movaps %xmm5, -0x480(%rbp)
movaps %xmm6, -0x470(%rbp)
movaps %xmm7, -0x460(%rbp)
movq %r9, -0x4d8(%rbp)
movq %r8, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movq %rdx, -0x4f0(%rbp)
movq %rsi, -0x4f8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
leaq -0x18(%rbp), %rsi
callq 0x2140
leaq -0x440(%rbp), %rax
leaq -0x500(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x22, %esi
leaq 0x89e(%rip), %rdx       # 0x42bc
movb $0x0, %al
callq 0x2210
leaq -0x420(%rbp), %rdi
addq $0x21, %rdi
movq -0x8(%rbp), %rdx
leaq -0x440(%rbp), %rcx
movl $0x3de, %esi            # imm = 0x3DE
callq 0x20d0
leaq -0x440(%rbp), %rax
leaq -0x420(%rbp), %rdi
callq 0x20b0
movl %eax, -0x444(%rbp)
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x420(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x3a89
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x420(%rbp,%rax)
leaq 0x824(%rip), %rdi       # 0x42b4
xorl %eax, %eax
leaq -0x420(%rbp), %rsi
callq 0x2030
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nopw (%rax,%rax)
// File: fanchenxinok[P]gtest-lcov/logout/log_out.c
// Function: getColorValueStr
void getColorValueStr(LOG_COLOR color, TYPE type, char valueStr[3])
{
    if(type == BACKGROUND)
        valueStr[0] = '4';
    else
        valueStr[0] = '3';

    switch(color)
    {
        case BLACK:
            valueStr[1] = '0';
            break;
        case RED:
            valueStr[1] = '1';
            break;
        case GREEN:
            valueStr[1] = '2';
            break;
        case YELLOW:
            valueStr[1] = '3';
            break;
        case BLUE:
            valueStr[1] = '4';
            break;
        case MAGENTA:
            valueStr[1] = '5';
            break;
        case CYAN:
            valueStr[1] = '6';
            break;
        case WHITE:
            valueStr[1] = '7';
            break;
        default:
            valueStr[1] = '0';
            break;
    }
    valueStr[2] = '\0';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x3c1d
movq -0x10(%rbp), %rax
movb $0x34, (%rax)
jmp 0x3c24
movq -0x10(%rbp), %rax
movb $0x33, (%rax)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x3c95
movq -0x18(%rbp), %rax
leaq 0x63c(%rip), %rcx       # 0x4278
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movb $0x30, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x31, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x32, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x33, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x34, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x35, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x36, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x37, 0x1(%rax)
jmp 0x3c9d
movq -0x10(%rbp), %rax
movb $0x30, 0x1(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x2(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x510, %rsp            # imm = 0x510
testb %al, %al
je 0x3cf7
movaps %xmm0, -0x4d0(%rbp)
movaps %xmm1, -0x4c0(%rbp)
movaps %xmm2, -0x4b0(%rbp)
movaps %xmm3, -0x4a0(%rbp)
movaps %xmm4, -0x490(%rbp)
movaps %xmm5, -0x480(%rbp)
movaps %xmm6, -0x470(%rbp)
movaps %xmm7, -0x460(%rbp)
movq %r9, -0x4d8(%rbp)
movq %r8, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x2140
leaq -0x423(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x20c0
leaq -0x426(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x20c0
movl -0x8(%rbp), %edi
leaq -0x426(%rbp), %rdx
xorl %esi, %esi
callq 0x3c00
movl -0x4(%rbp), %edi
leaq -0x423(%rbp), %rdx
movl $0x1, %esi
callq 0x3c00
leaq -0x440(%rbp), %rax
leaq -0x500(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x420(%rbp), %rdi
leaq -0x423(%rbp), %rcx
leaq -0x426(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x18(%rbp), %rax
movl $0x1e, %esi
leaq 0x535(%rip), %rdx       # 0x42f4
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2210
leaq -0x420(%rbp), %rdi
addq $0x1d, %rdi
movq -0x10(%rbp), %rdx
leaq -0x440(%rbp), %rcx
movl $0x3e2, %esi            # imm = 0x3E2
callq 0x20d0
leaq -0x440(%rbp), %rax
leaq -0x420(%rbp), %rdi
callq 0x20b0
movl %eax, -0x444(%rbp)
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x420(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x3e2e
movl -0x444(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x420(%rbp,%rax)
leaq 0x47f(%rip), %rdi       # 0x42b4
xorl %eax, %eax
leaq -0x420(%rbp), %rsi
callq 0x2030
addq $0x510, %rsp            # imm = 0x510
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x2d40
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x2d90
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rdi
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rsi
callq 0x2410
jmp 0x237b
leaq -0xb8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x2490
jmp 0x239e
leaq -0xd0(%rbp), %rdi
callq 0x2db0
jmp 0x23ac
movl $0x0, -0x4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x2e30
leaq -0xb8(%rbp), %rdi
callq 0x2ed0
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x2e30
leaq -0xb8(%rbp), %rdi
callq 0x2ed0
movq -0xe0(%rbp), %rdi
callq 0x21c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x58, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4140
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
movq %rax, %rdi
subq $-0x80, %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
callq 0x4180
jmp 0x40b6
movq -0x50(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x41d0
jmp 0x40c5
movq -0x50(%rbp), %rdi
movl $0x1, 0x50(%rdi)
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2190
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x4200
jmp 0x40f8
movq -0x50(%rbp), %rdi
movl $0x0, 0x50(%rdi)
addq $0x80, %rdi
callq 0x2190
leaq -0x20(%rbp), %rdi
callq 0x4250
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4250
movq -0x30(%rbp), %rdi
callq 0x21c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x58, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4140
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movq %rax, %rdi
subq $-0x80, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x5620
jmp 0x55a3
movq -0x40(%rbp), %rdi
callq 0x5670
movq %rax, -0x48(%rbp)
jmp 0x55b2
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
callq 0x5690
jmp 0x55c6
movq -0x40(%rbp), %rdi
movl $0x2, 0x50(%rdi)
addq $0x80, %rdi
callq 0x2190
movl -0x30(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4250
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0x8(%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl 0x1c(%rsp), %eax
shll $0x4, %eax
orl (%rdi), %eax
movl %eax, (%rdi)
movl 0x18(%rsp), %eax
shll $0x8, %eax
orl (%rdi), %eax
movl %eax, (%rdi)
xorl %esi, %esi
callq 0xb980
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x1c(%rsp), %ecx
imull 0x18(%rsp), %ecx
cmpl %ecx, %eax
jae 0x7d47
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x14(%rsp), %edx
addl $0x1, %edx
callq 0xb9c0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7d14
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x7e07
movl $0x4, %edi
callq 0xba70
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x7dac
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xbac0
jmp 0x7df5
cmpl $0x1, 0xc(%rsp)
jne 0x7dc6
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xbb30
jmp 0x7df3
cmpl $0x2, 0xc(%rsp)
jne 0x7de0
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xbbb0
jmp 0x7df1
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0xbc30
jmp 0x7df3
jmp 0x7df5
jmp 0x7df7
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7d76
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::set_tile(unsigned int, unsigned int)
void set_tile(unsigned t, unsigned pos) {
        unsigned shift = pos < 8 ? pos << 2 : (pos - 8) << 2;
        if( pos < 8 ) {
            d1_ &= ~(0xF << shift);
            d1_ |= t<<shift;
        } else {
            d2_ &= ~(0xF << shift);
            d2_ |= t << shift;
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x8, -0x10(%rsp)
jae 0xb9eb
movl -0x10(%rsp), %eax
shll $0x2, %eax
movl %eax, -0x24(%rsp)
jmp 0xb9f9
movl -0x10(%rsp), %eax
subl $0x8, %eax
shll $0x2, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x14(%rsp)
cmpl $0x8, -0x10(%rsp)
jae 0xba37
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
movl $0xf, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0xc(%rsp), %edx
movl -0x14(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0xba64
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
movl $0xf, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rsp), %edx
movl -0x14(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbcc0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jb 0xbb28
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
subl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0xbcd0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0xb9c0
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xb980
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbcc0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
xorl %edx, %edx
divl 0x18(%rsp)
movl 0x18(%rsp), %eax
subl $0x1, %eax
cmpl %eax, %edx
jae 0xbba2
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0xbcd0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0xb9c0
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xb980
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbcc0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
imull 0x18(%rsp), %ecx
cmpl %ecx, %eax
jae 0xbc23
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0xbcd0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0xb9c0
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xb980
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xbcc0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
xorl %edx, %edx
divl 0x18(%rsp)
cmpl $0x0, %edx
jbe 0xbc9c
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0xbcd0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0xb9c0
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0xb980
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rdi
callq 0xc270
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0xc290
movq 0x20(%rsp), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc063
movq 0x20(%rsp), %rdx
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
addq $0x20, %rdx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc400
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc3d0
jmp 0xbfa4
leaq 0x48(%rsp), %rdi
callq 0xc440
cmpl $0x0, 0x64(%rsp)
jne 0xbff4
movq 0x58(%rsp), %rdi
callq 0xc450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
movl 0x1c(%rax), %edx
callq 0xbac0
jmp 0xc061
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc440
jmp 0xc0f6
cmpl $0x3, 0x64(%rsp)
jne 0xc01a
movq 0x58(%rsp), %rdi
callq 0xc450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
movl 0x1c(%rax), %edx
callq 0xbb30
jmp 0xc05f
cmpl $0x2, 0x64(%rsp)
jne 0xc040
movq 0x58(%rsp), %rdi
callq 0xc450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
movl 0x1c(%rax), %edx
callq 0xbbb0
jmp 0xc05d
movq 0x58(%rsp), %rdi
callq 0xc450
movq %rax, %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
movl 0x1c(%rax), %edx
callq 0xbc30
jmp 0xc05f
jmp 0xc061
jmp 0xc063
movq 0x20(%rsp), %rax
movss 0x44f98(%rip), %xmm0    # 0x51008
subss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc0f1
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x68(%rsp), %rsi
movss 0x20(%rax), %xmm1
movss 0x44f6b(%rip), %xmm0    # 0x51008
subss %xmm1, %xmm0
movss %xmm0, 0x28(%rsp)
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rdx
callq 0xc490
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc3d0
jmp 0xc0cb
leaq 0x2c(%rsp), %rdi
callq 0xc440
jmp 0xc0f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0xc440
jmp 0xc0f6
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x6480
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x3, %rax
ja 0xc256
movq 0x10(%rsp), %rax
leaq 0x44e4e(%rip), %rcx     # 0x5101c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
callq 0xbcc0
cmpl 0x20(%rsp), %eax
setae %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xc25b
movq 0x8(%rsp), %rdi
callq 0xbcc0
xorl %edx, %edx
divl 0x20(%rsp)
movl 0x20(%rsp), %eax
subl $0x1, %eax
cmpl %eax, %edx
setb %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xc25b
movq 0x8(%rsp), %rdi
callq 0xbcc0
addl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
imull 0x20(%rsp), %ecx
cmpl %ecx, %eax
setb %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xc25b
movq 0x8(%rsp), %rdi
callq 0xbcc0
xorl %edx, %edx
divl 0x20(%rsp)
cmpl $0x0, %edx
seta %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xc25b
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0xd820
movq 0x30(%rsp), %rdi
movl %eax, 0x28(%rsp)
callq 0xd840
movl 0x28(%rsp), %ecx
movl %eax, %edx
movl 0x2c(%rsp), %eax
imull %edx, %ecx
cmpl %ecx, %eax
jae 0xd80f
movq 0x30(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0xbcc0
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
je 0xd7fd
movq 0x30(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0xbcd0
movq 0x30(%rsp), %rdi
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
callq 0xd840
movq 0x30(%rsp), %rdi
movl %eax, %ecx
movl 0xc(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, 0x14(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0xd840
movq 0x30(%rsp), %rdi
movl %eax, %ecx
movl 0x10(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
callq 0xd840
movq 0x30(%rsp), %rdi
movl %eax, %ecx
movl 0x18(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x20(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0xd840
movl %eax, %ecx
movl 0x1c(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl 0x20(%rsp), %edx
subl %eax, %edx
movl %edx, 0x3c(%rsp)
cmpl $0x0, 0x40(%rsp)
jge 0xd7c3
xorl %eax, %eax
subl 0x40(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0xd7cb
movl 0x40(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0xd7e5
xorl %eax, %eax
subl 0x3c(%rsp), %eax
movl %eax, (%rsp)
jmp 0xd7ec
movl 0x3c(%rsp), %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
addl %ecx, %eax
addl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0xd7ff
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0xd6b3
movl 0x4c(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::operator=(state_t const&)
const state_t& operator=(const state_t &s) {
        d0_ = s.d0_;
        d1_ = s.d1_;
        d2_ = s.d2_;
        return *this;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x2b1a9(%rip), %rsi     # 0x51b5d
callq 0x62b0
movq %rax, 0x38(%rsp)
movl $0x2, %edi
callq 0x26b10
movq 0x38(%rsp), %rdi
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %esi
callq 0x6340
movq 0x40(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0xbcc0
movq 0x48(%rsp), %rdi
movl %eax, %esi
callq 0x63a0
movq %rax, %rdi
leaq 0x2b15e(%rip), %rsi     # 0x51b5d
callq 0x62b0
movl $0x0, 0x50(%rsp)
movq 0x40(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, 0x34(%rsp)
callq 0xd820
movq 0x40(%rsp), %rdi
movl %eax, 0x30(%rsp)
callq 0xd840
movl 0x30(%rsp), %ecx
movl %eax, %edx
movl 0x34(%rsp), %eax
imull %edx, %ecx
cmpl %ecx, %eax
jae 0x26b08
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0xbcc0
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jne 0x26a6f
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x26a84
movq 0x40(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0xbcd0
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x63a0
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x18(%rsp)
callq 0xd820
movq 0x40(%rsp), %rdi
movl %eax, 0x14(%rsp)
callq 0xd840
movl 0x14(%rsp), %ecx
movl %eax, %edx
movl 0x18(%rsp), %eax
imull %edx, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x26add
leaq 0x2af7d(%rip), %rax     # 0x51a54
movq %rax, (%rsp)
jmp 0x26aea
leaq 0x2b079(%rip), %rax     # 0x51b5d
movq %rax, (%rsp)
jmp 0x26aea
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x62b0
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x26a0c
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x13c0
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x2daa(%rip), %rdi      # 0x3fb8
callq 0x1400
movq %rax, %rsi
movq 0x2dbb(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, -0x58(%rbp)
jmp 0x1228
movq -0x58(%rbp), %rdi
leaq 0xdd1(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, -0x68(%rbp)
jmp 0x123e
leaq 0x2aab(%rip), %rdi      # 0x3cf0
callq 0x1400
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, -0x70(%rbp)
jmp 0x125c
movq -0x70(%rbp), %rdi
leaq 0xd9d(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, -0x78(%rbp)
jmp 0x1272
leaq 0x2a87(%rip), %rdi      # 0x3d00
callq 0x1400
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, -0x80(%rbp)
jmp 0x1290
movq -0x80(%rbp), %rdi
leaq 0xd69(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, -0x88(%rbp)
jmp 0x12a9
leaq 0x2a60(%rip), %rdi      # 0x3d10
callq 0x1400
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, -0x90(%rbp)
jmp 0x12cd
movq -0x90(%rbp), %rdi
leaq 0xd29(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, -0x98(%rbp)
jmp 0x12e9
leaq 0x2a40(%rip), %rdi      # 0x3d30
callq 0x1400
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, -0xa0(%rbp)
jmp 0x130d
movq -0xa0(%rbp), %rdi
leaq 0xce9(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, -0xa8(%rbp)
jmp 0x1329
movq -0x40(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
jne 0x1341
callq 0x1070
jmp 0x1341
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0x1400
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, -0xb8(%rbp)
jmp 0x136c
movq -0xb8(%rbp), %rdi
movq 0x2c4e(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x1381
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1440
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1440
movq -0x48(%rbp), %rdi
callq 0x1090
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5bb80
jmp 0x5bed2
jmp 0x5bf0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5bf15
movq -0x28(%rbp), %rdi
callq 0x10270
movq %rax, -0x38(%rbp)
callq 0x109e0
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10290
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10a90
nop