LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lolonet[P]Timer/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	const int epfd = epoll_create(1);
	epoll_event events[1] = {};

	TimerContraller timeCtl;
	Timer timer(&timeCtl);
	timer.StartTimer(100, 3, timeoutNotify);
	timer.StartTimer(101, 6, timeoutNotify);
	timer.StartTimer(102, 4, otherTimeoutNotify);

	const int minEpollTime = 1000;			// 1000 msec
	while(true)
	{
		epoll_wait(epfd, events, sizeof(events)/sizeof(epoll_event), minEpollTime);
		timeCtl.CheckExpire();

		cout<<" contral list " << timeCtl.GetTimerListSize() <<" contral queue " << timeCtl.GetTimerQueueSize() <<endl;

	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0x21d0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2660
movq -0xc0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x26c0
jmp 0x24da
leaq -0x181(%rip), %rcx      # 0x2360
leaq -0xa8(%rbp), %rdi
movl $0x64, %esi
movl $0x3, %edx
callq 0x3a80
jmp 0x24f9
leaq -0x1a0(%rip), %rcx      # 0x2360
leaq -0xa8(%rbp), %rdi
movl $0x65, %esi
movl $0x6, %edx
callq 0x3a80
jmp 0x2518
leaq -0xef(%rip), %rcx       # 0x2430
leaq -0xa8(%rbp), %rdi
movl $0x66, %esi
movl $0x4, %edx
callq 0x3a80
jmp 0x2537
movl $0x3e8, -0xb8(%rbp)     # imm = 0x3E8
jmp 0x2543
movl -0x14(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
movl $0x3e8, %ecx            # imm = 0x3E8
callq 0x2080
jmp 0x255b
leaq -0x70(%rbp), %rdi
callq 0x3af0
jmp 0x2566
movq 0xaa6b(%rip), %rdi      # 0xcfd8
leaq 0x5adc(%rip), %rsi      # 0x8050
callq 0x20f0
movq %rax, -0xc8(%rbp)
jmp 0x2582
leaq -0x70(%rbp), %rdi
callq 0x3be0
movl %eax, -0xcc(%rbp)
jmp 0x2593
movl -0xcc(%rbp), %esi
movq -0xc8(%rbp), %rdi
callq 0x21b0
movq %rax, -0xd8(%rbp)
jmp 0x25ae
movq -0xd8(%rbp), %rdi
leaq 0x5aa3(%rip), %rsi      # 0x805f
callq 0x20f0
movq %rax, -0xe0(%rbp)
jmp 0x25ca
leaq -0x70(%rbp), %rdi
callq 0x3c00
movl %eax, -0xe4(%rbp)
jmp 0x25db
movl -0xe4(%rbp), %esi
movq -0xe0(%rbp), %rdi
callq 0x21b0
movq %rax, -0xf0(%rbp)
jmp 0x25f6
movq -0xf0(%rbp), %rdi
movq 0xa9c4(%rip), %rsi      # 0xcfc8
callq 0x2130
jmp 0x260b
jmp 0x2541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x26f0
leaq -0x70(%rbp), %rdi
callq 0x2710
movq -0xb0(%rbp), %rdi
callq 0x21c0
nopw (%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerObject::StopTimer()
int TimerObject::StopTimer(void)
{
	if (m_pTimer == NULL || m_pTimer->m_pTimeContraller == NULL)
		return -1;

	// 向 timeout epoll 发送消息, 移除定时器
	m_pTimer->m_pTimeContraller->DeleteTimer(this);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x365a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3663
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x367b
movq -0x18(%rbp), %rsi
movq 0x10(%rsi), %rax
movq 0x30(%rax), %rdi
callq 0x3690
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerContraller::DeleteTimer(TimerObject*)
int TimerContraller::DeleteTimer(TimerObject *pTimerObj)
{
	const int64 timeout = TimerContraller::TransToTimeStamp(pTimerObj->GetTimeOut());
	map<int64, list<TimerObject*> >::iterator itList = m_SameTimerList.find(timeout);
	if (itList == m_SameTimerList.end())
		return 0;

	list<TimerObject*> &timeList = m_SameTimerList[timeout];
	list<TimerObject*>::iterator it = std::find(timeList.begin(), timeList.end(), pTimerObj);
	if (it != timeList.end())
		timeList.erase(it);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3950
movl %eax, %edi
callq 0x3e30
movq -0x70(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x3fd0
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x4030
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4000
testb $0x1, %al
jne 0x36f0
jmp 0x36fc
movl $0x0, -0x4(%rbp)
jmp 0x3789
movq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3eb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40b0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40e0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4060
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40e0
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4110
testb $0x1, %al
jne 0x375c
jmp 0x3782
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4190
movq -0x78(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x4140
movq %rax, -0x68(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerObject::StartTimer(int, int (*)(int))
int TimerObject::StartTimer(int timeout, TimerCallback *func)
{
	if (func == NULL || m_pTimer == NULL || m_pTimer->m_pTimeContraller == NULL)
		return -1;

	this->m_timeout = timeout;
	this->m_func = func;
	// 向 timeout epoll 注册定时器， 将this 添加到全局最小堆结构
	m_pTimer->m_pTimeContraller->RegisterTimer(this);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x37dc
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x37dc
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x30(%rax)
jne 0x37e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x380b
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, 0x4(%rsi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq 0x30(%rax), %rdi
callq 0x3820
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerContraller::RegisterTimer(TimerObject*)
int TimerContraller::RegisterTimer(TimerObject *pTimerObj)
{
	if (pTimerObj == NULL)
		return -1;

	const int64 timeout = TimerContraller::TransToTimeStamp(pTimerObj->GetTimeOut());
	m_TimerQueue.push(timeout);
	m_SameTimerList[timeout].push_back(pTimerObj);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3848
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x388d
movq -0x18(%rbp), %rdi
callq 0x3950
movl %eax, %edi
callq 0x3e30
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3e60
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3eb0
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: Timer::StopTimer(int)
int Timer::StopTimer(int timeid)
{
	map<int, TimerObject*>::iterator it = m_timerMap.find(timeid);
	if (it != m_timerMap.end())
		m_timerMap.erase(it);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x3c20
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3c80
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3c50
testb $0x1, %al
jne 0x3924
jmp 0x393d
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x3df0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: Timer::GetTimerObj(int)
TimerObject* Timer::GetTimerObj(int timeid)
{
	map<int, TimerObject*>::iterator itObj = m_timerMap.find(timeid);
	if (itObj != m_timerMap.end() && itObj->second != NULL)
		return itObj->second;

	TimerObject *pTimeObj = new TimerObject(this, timeid);
	m_timerMap[timeid] = pTimeObj;
	return pTimeObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x3c20
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3c80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3c50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3d(%rbp)
jne 0x39cc
jmp 0x39e0
leaq -0x20(%rbp), %rdi
callq 0x3cb0
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x39e9
jmp 0x39fc
leaq -0x20(%rbp), %rdi
callq 0x3cb0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a68
movl $0x18, %edi
callq 0x2100
movq -0x48(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %edx
callq 0x3ce0
jmp 0x3a1e
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x3d10
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a68
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x18, %esi
callq 0x2110
jmp 0x3a72
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x21c0
nopl (%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: Timer::StartTimer(int, int, int (*)(int))
int Timer::StartTimer(int timeid, int timeout, TimerCallback *func)
{
	if (func == NULL)
		return -1;

	TimerObject *pTimeObj = this->GetTimerObj(timeid);
	pTimeObj->StopTimer();
	pTimeObj->StartTimer(timeout, func);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3aae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ade
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3980
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3630
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x37a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerContraller::CheckExpire()
int TimerContraller::CheckExpire(void)
{
	const int64 now = TimerContraller::GetTimeStamp();

	while(!m_TimerQueue.empty())
	{
		const int64 minExpire = m_TimerQueue.top();
		if (minExpire > now)
			break;

		// time out 
		list<TimerObject*> &timeList = m_SameTimerList[minExpire];
		while(!timeList.empty())
		{
			TimerObject *pTimerObj = timeList.front();
			timeList.pop_front();
			pTimerObj->TimeOutNotify();
			delete pTimerObj;
		}

		m_SameTimerList.erase(minExpire);
		m_TimerQueue.pop();
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x41b0
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x4210
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b25
jmp 0x3bc9
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x4230
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x3b48
jmp 0x3bc9
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3eb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4250
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b6a
jmp 0x3baa
movq -0x20(%rbp), %rdi
callq 0x4270
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42a0
movq -0x28(%rbp), %rdi
callq 0x38a0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3ba8
movq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x2110
jmp 0x3b59
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x42d0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x4300
jmp 0x3b0d
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lolonet[P]Timer/Timer.cpp
// Function: TimerContraller::GetTimeStamp()
inline int64 TimerContraller::GetTimeStamp(void)
{
	struct timeval tv = {};
	gettimeofday(&tv, NULL);
	const int64 time = tv.tv_sec * TIMESTAMP_PRECISION + tv.tv_usec%TIMESTAMP_PRECISION;
	return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20a0
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2170
imulq $0xf4240, -0x10(%rbp), %rax # imm = 0xF4240
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq -0x20(%rbp), %rax
addq %rdx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ctSkennerton[P]fxtract/util/bitmat_t.c
// Function: main
int
main(void)
{
    plan_tests(5);
    setvbuf(stdout, 0, _IOLBF, 0);
    int pts[] = { 1,3, 2,5, 4,0, 8,9, 5,20, 6,23, 10,10, 10,11, 10,12, 15,22, 13,23, -1 };
    
    dotest( 8,  8, pts);
    dotest( 8, 24, pts);
    dotest(16, 16, pts);
    dotest(16, 24, pts);
    dotest(24, 24, pts);
 
    return exit_status();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x5, %edi
callq 0x6e70
movq 0x7af8(%rip), %rax      # 0xafc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x3030
leaq -0x60(%rbp), %rdi
leaq 0x4b21(%rip), %rsi      # 0x8010
movl $0x5c, %edx
callq 0x3160
leaq -0x60(%rbp), %rdx
movl $0x8, %esi
movl %esi, %edi
callq 0x3560
leaq -0x60(%rbp), %rdx
movl $0x8, %edi
movl $0x18, %esi
callq 0x3560
leaq -0x60(%rbp), %rdx
movl $0x10, %esi
movl %esi, %edi
callq 0x3560
leaq -0x60(%rbp), %rdx
movl $0x10, %edi
movl $0x18, %esi
callq 0x3560
leaq -0x60(%rbp), %rdx
movl $0x18, %esi
movl %esi, %edi
callq 0x3560
callq 0x71c0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/bitmat_t.c
// Function: dotest
void
dotest(int nrows, int ncols, int *xys)
{
    BITMAT *inp = bitmat(nrows, ncols);
    BITMAT *exp = bitmat(ncols, nrows);

    for (; *xys >= 0; xys += 2) {
        bitmat_set(inp, xys[0] % nrows, xys[1] % ncols, 1);
        bitmat_set(exp, xys[1] % ncols, xys[0] % nrows, 1);
    }

    BITMAT *act = bitmat_trans(inp);
    int rc = refcmp(bitmat_ref(act), bitmat_ref(exp));
    ok(!rc, "trans %d x %d", nrows, ncols);
    if (rc) {
        puts("expected:"); prbm(exp);
        puts("actual:"); prbm(act);
    }

    bitmat_destroy(inp);
    bitmat_destroy(exp);
    bitmat_destroy(act);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x37e0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x37e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x35f2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0xc(%rbp)
movl %edx, %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cltd
idivl -0x10(%rbp)
movl $0x1, %ecx
callq 0x3960
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cltd
idivl -0x10(%rbp)
movl %edx, %esi
movq -0x18(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0xc(%rbp)
movl $0x1, %ecx
callq 0x3960
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x3591
movq -0x20(%rbp), %rdi
callq 0x3b10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3ad0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3ad0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x58b0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3690
movl -0xc(%rbp), %r10d
movl -0x10(%rbp), %eax
xorl %edi, %edi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x4a13(%rip), %r9       # 0x806c
leaq 0x4a13(%rip), %rbx      # 0x8073
leaq 0x4a17(%rip), %r11      # 0x807e
movq %r8, %rdx
movq %r8, %rcx
movq %rbx, (%rsp)
movl $0x38, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x6190
jmp 0x36dd
movl -0xc(%rbp), %r10d
movl -0x10(%rbp), %eax
xorl %edi, %edi
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x49c7(%rip), %r9       # 0x806c
leaq 0x49c7(%rip), %rbx      # 0x8073
leaq 0x49cb(%rip), %r11      # 0x807e
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
movq %rbx, (%rsp)
movl $0x38, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x6190
cmpl $0x0, -0x34(%rbp)
je 0x370d
leaq 0x49a2(%rip), %rdi      # 0x808c
callq 0x3300
movq -0x28(%rbp), %rdi
callq 0x3730
leaq 0x4997(%rip), %rdi      # 0x8096
callq 0x3300
movq -0x30(%rbp), %rdi
callq 0x3730
movq -0x20(%rbp), %rdi
callq 0x3890
movq -0x28(%rbp), %rdi
callq 0x3890
movq -0x30(%rbp), %rdi
callq 0x3890
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/bitmat_t.c
// Function: prbm
void
prbm(BITMAT const*bmp)
{
    int r, c, nrows = bitmat_rows(bmp), ncols = bitmat_cols(bmp);

    for (r = 0; r < nrows; ++r) {
        printf("%3d ", r);
        for (c = 0; c < ncols; ++c) {
            if (!(c & 7)) putchar(' ');
            putchar("-#"[bitmat_get(bmp, r, c)]);
        }
        putchar('\n');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a90
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ab0
movl %eax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x37da
movl -0xc(%rbp), %esi
leaq 0x4931(%rip), %rdi      # 0x809e
movb $0x0, %al
callq 0x3050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x37c5
movl -0x10(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x3798
movl $0x20, %edi
callq 0x3290
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x38c0
movslq %eax, %rcx
leaq 0x48f2(%rip), %rax      # 0x80a3
movsbl (%rax,%rcx), %edi
callq 0x3290
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x377b
movl $0xa, %edi
callq 0x3290
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x375b
addq $0x20, %rsp
popq %rbp
retq
// File: ctSkennerton[P]fxtract/util/bitmat.c
// Function: bitmat
BITMAT*
bitmat(int nrows, int ncols)
{
    assert (nrows % 8 == 0 && ncols % 8 == 0);
    BITMAT *bmp = (BITMAT *) malloc(sizeof*bmp);
    *bmp = (BITMAT) { (uint8_t *) calloc(nrows, ncols/8), nrows, ncols };
    return bmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3810
movl -0x8(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3810
jmp 0x382f
leaq 0x488f(%rip), %rdi      # 0x80a6
leaq 0x48a9(%rip), %rsi      # 0x80c7
movl $0x1e, %edx
leaq 0x48a6(%rip), %rcx      # 0x80d0
callq 0x3130
movl $0x10, %edi
callq 0x3270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rdi
movl -0x8(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0x3140
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl -0x8(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/bitmat.c
// Function: bitmat_set
void
bitmat_set(BITMAT *bmp, int row, int col, int val)
{
    assert((unsigned)row < bmp->nrows && (unsigned)col < bmp->ncols);
    col += row * bmp->ncols;
    uint8_t bit = 1 << (col & 7), *at = &bmp->data[col >> 3];
    *at = val ? *at | bit : *at & ~bit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x398f
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x398f
jmp 0x39ae
leaq 0x4753(%rip), %rdi      # 0x80e9
leaq 0x472a(%rip), %rsi      # 0x80c7
movl $0x35, %edx
leaq 0x47a2(%rip), %rcx      # 0x814b
callq 0x3130
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %eax
shll %cl, %eax
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x39fe
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzbl -0x15(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a11
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzbl -0x15(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: LinkedList::~LinkedList()
LinkedList::~LinkedList()
{
	while(head)
	{
		Node* tmp = head;
		head = head->next;
		delete tmp;
		tmp = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x404648
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x40463e
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x404c60
movq $0x0, -0x10(%rbp)
jmp 0x404604
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: LinkedList::prepend(int)
void LinkedList::prepend(int data)
{
	// check if link is empty
	if(!head)
	{
		head = new Node(data);
	}
	else
	{
		Node* node = new Node(data);
		node->next = head;
		head = node;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x4046f4
movl $0x10, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x404c20
jmp 0x4046cb
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x40474d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x404c60
jmp 0x404753
movl $0x10, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0x404c20
jmp 0x404712
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x40474d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x404c60
jmp 0x404753
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4a5830
nopl (%rax)
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: LinkedList::indexInsertion(int, int)
void LinkedList::indexInsertion(int data, int index)
{
	if (index == 0)
	{
		this->prepend(data);
	}
	else if ( index == size())
	{
		this->append(data);
	}
	else
	{
		int count = 0;
		Node* curr = head;
		Node* prev = NULL;
		for(;count != index; count++, prev = curr, curr=curr->next);
		Node* newNode = new Node(data);
		newNode->next = curr;
		prev->next = newNode;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x404791
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x404690
jmp 0x404858
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x404650
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jne 0x4047ba
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x404870
jmp 0x404856
movq -0x48(%rbp), %rax
movl $0x0, -0x14(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x4047fc
jmp 0x4047de
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4047d4
movl $0x10, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0x404c20
jmp 0x40481a
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x404856
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x404c60
jmp 0x40485e
jmp 0x404858
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4a5830
nopw (%rax,%rax)
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: LinkedList::append(int)
void LinkedList::append(int data)
{
	// check if head is null
	if(!head)
	{
		head = new Node(data);
	}
	else
	{
		Node* curr = head;
		for(;curr->next != NULL; curr = curr->next);
		curr->next = new Node(data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x4048d7
movl $0x10, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x404c20
jmp 0x4048ab
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x404942
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x404c60
jmp 0x404948
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4048fb
jmp 0x4048ee
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4048e2
movl $0x10, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0x404c20
jmp 0x404919
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x404942
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x404c60
jmp 0x404948
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4a5830
nopw %cs:(%rax,%rax)
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: operator<<(std::ostream&, LinkedList&)
ostream& operator<<(ostream &os, LinkedList&obj)
{
	for(Node* curr = obj.head; curr != NULL; curr=curr->next)
	{

		if(curr->next == NULL)
		{
			os<<curr->getData();
		}
		else
		{
			os<<curr->getData()<<",";
		}
	}
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4049e4
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4049aa
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x404c40
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x46dfe0
jmp 0x4049d5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x404c40
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x46dfe0
movq %rax, %rdi
leaq 0x171634(%rip), %rsi    # 0x576004
callq 0x46dc40
jmp 0x4049d7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x40497b
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Tumelo4[P]-Single-Linked-List-In-CPP/LinkedList.cpp
// Function: LinkedList::reverse()
void LinkedList::reverse()
{
	if( head != NULL && size()> 1)
	{
		Node* curr = head;
		Node* prev = NULL;
		Node* prevprev = NULL;
		bool flag = false;

		for(;curr != NULL;prevprev = prev,prev=curr,curr = curr->next)
		{
			if(flag == false)
			{
				if(prevprev != NULL)
				{
					prevprev->next = NULL;
					prev->next = prevprev;
					flag = true;
				}
			}
			else
			{
				prev->next = prevprev;
			}
		}
		if (size() == 2)
		{
			prevprev->next = NULL;
			prev->next = prevprev;
		}
		else
		{
			prev->next = prevprev;
		}
		head = prev;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x404adc
movq -0x30(%rbp), %rdi
callq 0x404650
cmpl $0x1, %eax
jle 0x404adc
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x404aa0
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x404a76
cmpq $0x0, -0x20(%rbp)
je 0x404a74
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x21(%rbp)
jmp 0x404a81
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x404a83
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x404a3f
movq -0x30(%rbp), %rdi
callq 0x404650
cmpl $0x2, %eax
jne 0x404ac6
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x404ad1
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Tumelo4[P]-Single-Linked-List-In-CPP/Main.cpp
// Function: main
int main()
{
	LinkedList* linkedList = new LinkedList();

	linkedList->append(2);
	linkedList->append(4);
	linkedList->prepend(1);
	linkedList->indexInsertion(0,0);
	linkedList->indexInsertion(5,4);
	linkedList->indexInsertion(3,3);
	//cout<<linkedList<<"\n";  output memory
	cout<<*linkedList<<"\n";
	linkedList->reverse();
	cout<<*linkedList<<"\n";
	delete linkedList;
	linkedList = NULL;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x405960
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4045d0
jmp 0x404b1a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x404870
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x404870
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x404690
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x404760
movq -0x10(%rbp), %rdi
movl $0x5, %esi
movl $0x4, %edx
callq 0x404760
movq -0x10(%rbp), %rdi
movl $0x3, %edx
movl %edx, %esi
callq 0x404760
movq -0x10(%rbp), %rsi
movq $0x5e3440, %rdi         # imm = 0x5E3440
callq 0x404960
movq %rax, %rdi
leaq 0x178014(%rip), %rsi    # 0x57cbaa
callq 0x46dc40
movq -0x10(%rbp), %rdi
callq 0x4049f0
movq -0x10(%rbp), %rsi
movq $0x5e3440, %rdi         # imm = 0x5E3440
callq 0x404960
movq %rax, %rdi
leaq 0x177fec(%rip), %rsi    # 0x57cbaa
callq 0x46dc40
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x404be8
movq -0x30(%rbp), %rdi
callq 0x4045f0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x404c60
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x404c60
movq -0x18(%rbp), %rdi
callq 0x4a5830
nopl (%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::MP1Node(Member*, Params*, EmulNet*, Log*, Address*)
MP1Node::MP1Node(Member *member, Params *params, EmulNet *emul, Log *log, Address *address)
{
    for (int i = 0; i < 6; i++)
    {
        NULLADDR[i] = 0;
    }
    this->memberNode = member;
    this->this_node_ = *(int *)address;
    // std::cout << "this_node_: " << this_node_ << "\n";
    this->emulNet = emul;
    this->log = log;
    this->par = params;
    this->memberNode->addr = *address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x35191(%rip), %rax     # 0x39bf0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x6540
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x58(%rbp)
callq 0x6560
movq -0x50(%rbp), %rax
movl $0x0, 0xa0(%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x6, -0x34(%rbp)
jge 0x4ab7
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4a99
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xa4(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rsi
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x17100
jmp 0x4afa
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x6580
movq -0x60(%rbp), %rdi
callq 0x65a0
movq -0x40(%rbp), %rdi
callq 0x4570
nopw (%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::initThisNode(Address*)
int MP1Node::initThisNode(Address *joinaddr)
{
    /*
	 * This function is partially implemented and may require changes
	 */
    // int id = *(int *)(&memberNode->addr.addr);
    // int port = *(short *)(&memberNode->addr.addr[4]);

    memberNode->bFailed = false;
    memberNode->inited = true;
    memberNode->inGroup = false;
    // node is up!
    memberNode->nnb = 0;
    memberNode->heartbeat = 0;
    memberNode->pingCounter = TFAIL;
    memberNode->timeOutCounter = -1;
    initMemberListTable(memberNode);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x20(%rdi), %rax
movb $0x0, 0x10(%rax)
movq 0x20(%rdi), %rax
movb $0x1, 0xe(%rax)
movq 0x20(%rdi), %rax
movb $0x0, 0xf(%rax)
movq 0x20(%rdi), %rax
movl $0x0, 0x14(%rax)
movq 0x20(%rdi), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rdi), %rax
movl $0x5, 0x20(%rax)
movq 0x20(%rdi), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq 0x20(%rdi), %rsi
callq 0x4f50
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::introduceSelfToGroup(Address*)
int MP1Node::introduceSelfToGroup(Address *joinaddr)
{
#ifdef DEBUGLOG
    static char s[1024];
#endif

    if (0 == memcmp((char *)&(memberNode->addr.addr), (char *)&(joinaddr->addr), sizeof(memberNode->addr.addr)))
    {
        // I am the group booter (first process to join the group). Boot up the group
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, "Starting up group...");
#endif
        memberNode->inGroup = true;
        AddNode(this_node_);
    }
    else
    {
        size_t msgsize = sizeof(MessageHdr) + sizeof(joinaddr->addr) + sizeof(long) + 1;
        // cout << "msgsize: " << sizeof(MessageHdr) << " " << sizeof(joinaddr->addr) << " " << sizeof(long) << " " << 1 << "\n";
        MessageHdr *msg = (MessageHdr *)malloc(msgsize * sizeof(char));

        // create JOINREQ message: format of data is {struct Address myaddr}
        msg->msgType = JOINREQ;
        memcpy((char *)(msg + 1), &memberNode->addr.addr, sizeof(memberNode->addr.addr));
        memcpy((char *)(msg + 1) + 1 + sizeof(memberNode->addr.addr), &memberNode->heartbeat, sizeof(long));

#ifdef DEBUGLOG
        sprintf(s, "Trying to join...");
        log->LOG(&memberNode->addr, s);
#endif

        // send JOINREQ message to introducer member
        emulNet->ENsend(&memberNode->addr, joinaddr, (char *)msg, msgsize);
        free(msg);
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x4170
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4e80
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq 0x2520e(%rip), %rdx     # 0x2a06b
movb $0x0, %al
callq 0x15fd0
movq -0x28(%rbp), %rdi
movq 0x20(%rdi), %rax
movb $0x1, 0xf(%rax)
movl 0xa4(%rdi), %esi
callq 0x4f80
jmp 0x4f2d
movq $0x13, -0x18(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0x4460
movq -0x28(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rcx), %rdx
movl 0x8(%rdx), %esi
movl %esi, 0x4(%rax)
movw 0xc(%rdx), %dx
movw %dx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0xb(%rax)
leaq 0x3547c(%rip), %rdi     # 0x3a350
leaq 0x251a5(%rip), %rsi     # 0x2a080
movb $0x0, %al
callq 0x40a0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq 0x35457(%rip), %rdx     # 0x3a350
movb $0x0, %al
callq 0x15fd0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl %eax, %r8d
callq 0xcad0
movq -0x20(%rbp), %rdi
callq 0x43e0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::AddNode(int)
void MP1Node::AddNode(int node)
{
    if (m_.find(node) != m_.end())
        return;
    m_.insert(node);
    memberNode->memberList.emplace_back(node, 0);
    if (node == this_node_)
    {
        memberNode->inGroup = 1;
    }
    Address a(std::to_string(node) + ":0");
#ifdef DEBUGLOG
    log->logNodeAdd(&memberNode->addr, &a);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x6670
movq -0x98(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x30, %rdi
callq 0x66a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6640
testb $0x1, %al
jne 0x4fd5
jmp 0x4fda
jmp 0x50a5
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x66d0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x30(%rbp)
movb %dl, -0x28(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movl $0x0, -0x34(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x6710
movq -0x98(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xa4(%rcx), %eax
jne 0x503c
movq -0x98(%rbp), %rax
movq 0x20(%rax), %rax
movb $0x1, 0xf(%rax)
movl -0xc(%rbp), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x67e0
movq -0xa0(%rbp), %rsi
leaq 0x25035(%rip), %rdx     # 0x2a092
leaq -0x60(%rbp), %rdi
callq 0x6790
jmp 0x5068
leaq -0x3a(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6900
jmp 0x5077
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x80(%rbp), %rdi
callq 0x41e0
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq -0x3a(%rbp), %rdx
callq 0x16390
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x50dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x80(%rbp), %rdi
callq 0x41e0
movq -0x88(%rbp), %rdi
callq 0x4570
nopw %cs:(%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::nodeLoop()
void MP1Node::nodeLoop()
{
    // std::cout << "Start nodeLoop " << this_node_ << "\n";
    if (memberNode->bFailed)
    {
        return;
    }

    // Check my messages
    checkMessages();

    // Wait until you're in the group...
    if (!memberNode->inGroup)
    {
        return;
    }

    // ...then jump in and share your responsibilites!
    nodeLoopOps();

    // std::cout << "End nodeLoop\n";
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x20(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x5120
jmp 0x5142
movq -0x10(%rbp), %rdi
callq 0x5150
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
testb $0x1, 0xf(%rax)
jne 0x5139
jmp 0x5142
movq -0x10(%rbp), %rdi
callq 0x51e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: MP1Node::PublishToAll(MessageHdr const&, unsigned long)
void MP1Node::PublishToAll(const MessageHdr &msg, size_t size)
{
    // std::cout << "Start PublishToAll "
    // << " " << this_node_ << "," << msg.msgType << "\n";
    for (int i = 0; i < memberNode->memberList.size(); ++i)
    {
        auto &e = memberNode->memberList[i];
        if (e.getid() == this_node_)
            continue;
        Address a(std::to_string(e.getid()) + ":" + std::to_string(e.getport()));
        if (!emulNet->ENsend(&memberNode->addr, &a, (char *)&msg, size))
        {
            // failed to send to this node.
        }
    }
    // std::cout << "End PublishToAll\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0xc8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x6ad0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x5fec
movq -0xc8(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6b00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x172a0
movq -0xc8(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
jne 0x5e84
jmp 0x5fde
movq -0x28(%rbp), %rdi
callq 0x172a0
movl %eax, %esi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x67e0
movq -0xd8(%rbp), %rsi
leaq 0x24f31(%rip), %rdx     # 0x2ade1
leaq -0x70(%rbp), %rdi
callq 0x6790
jmp 0x5ebb
movq -0x28(%rbp), %rdi
callq 0x172b0
movw %ax, -0xda(%rbp)
jmp 0x5ecd
movw -0xda(%rbp), %ax
movswl %ax, %esi
leaq -0xc0(%rbp), %rdi
callq 0x67e0
jmp 0x5ee5
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x6e20
jmp 0x5efb
leaq -0x2e(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6900
jmp 0x5f0a
leaq -0x50(%rbp), %rdi
callq 0x41e0
leaq -0xc0(%rbp), %rdi
callq 0x41e0
leaq -0x70(%rbp), %rdi
callq 0x41e0
leaq -0x90(%rbp), %rdi
callq 0x41e0
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movl %eax, %r8d
leaq -0x2e(%rbp), %rdx
callq 0xcad0
cmpl $0x0, %eax
jne 0x5fdc
jmp 0x5fdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5fce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5fc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41e0
leaq -0xc0(%rbp), %rdi
callq 0x41e0
leaq -0x70(%rbp), %rdi
callq 0x41e0
leaq -0x90(%rbp), %rdi
callq 0x41e0
jmp 0x5ff5
jmp 0x5fde
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e19
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4570
nopw %cs:(%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP1Node.cpp
// Function: (anonymous namespace)::CreateMessage(MsgTypes, int, int)
MessageHdr *CreateMessage(MsgTypes type, int src, int target)
    {
        MessageHdr *msg = (MessageHdr *)malloc(MSGSIZE * sizeof(char));
        msg->msgType = type;
        memcpy((char *)(msg + 1), &src, sizeof(int));
        memcpy((char *)(msg + 1) + sizeof(int), &target, sizeof(int));
        return msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0xc, %edi
callq 0x4460
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP2Node.cpp
// Function: PrintRing(std::vector<Node, std::allocator<Node>>)
void PrintRing(std::vector<Node> ring)
{
	std::cout << "RING:";
	for (auto &node : ring)
	{
		std::cout << " " << node.getAddress()->getAddress();
	}
	std::cout << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x1e171(%rip), %rdi     # 0x39fc8
leaq 0xee5e(%rip), %rsi      # 0x2acbc
callq 0x42f0
movq -0x60(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20dc0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20df0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20e20
testb $0x1, %al
jne 0x1be98
jmp 0x1bf0f
leaq -0x18(%rbp), %rdi
callq 0x20e60
movq %rax, -0x28(%rbp)
movq 0x1e11c(%rip), %rdi     # 0x39fc8
leaq 0xe453(%rip), %rsi      # 0x2a306
callq 0x42f0
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25a90
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12740
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x42a0
jmp 0x1bee4
leaq -0x48(%rbp), %rdi
callq 0x41e0
leaq -0x18(%rbp), %rdi
callq 0x20e80
jmp 0x1be85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x1bf28
movq 0x1e0b2(%rip), %rdi     # 0x39fc8
leaq 0xe428(%rip), %rsi      # 0x2a345
callq 0x42f0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4570
nopw %cs:(%rax,%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP2Node.cpp
// Function: MP2Node::MP2Node(Member*, Params*, EmulNet*, Log*, Address*)
MP2Node::MP2Node(Member *memberNode, Params *par, EmulNet *emulNet, Log *log, Address *address)
{
	this->memberNode = memberNode;
	this->par = par;
	this->emulNet = emulNet;
	this->log = log;
	ht = new HashTable();
	secondary = new HashTable();
	tertiary = new HashTable();
	this->memberNode->addr = *address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x12bc0
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x68(%rbp)
callq 0x12bc0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x12bc0
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x20ea0
movq -0x50(%rbp), %rax
movl $0x0, 0xb0(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x78(%rax)
movl $0x38, %edi
callq 0x4310
movq %rax, -0x48(%rbp)
jmp 0x1bfe8
movq -0x48(%rbp), %rdi
callq 0x25b00
jmp 0x1bff3
movq -0x70(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl $0x38, %edi
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x1c00f
movq -0x78(%rbp), %rdi
callq 0x25b00
jmp 0x1c01a
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x50(%rax)
movl $0x38, %edi
callq 0x4310
movq %rax, -0x80(%rbp)
jmp 0x1c036
movq -0x80(%rbp), %rdi
callq 0x25b00
jmp 0x1c041
movq -0x70(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rsi
movq 0x60(%rax), %rdi
addq $0x8, %rdi
callq 0x17100
jmp 0x1c060
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1c0c9
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x4320
jmp 0x1c0c9
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x4320
jmp 0x1c0c9
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x4320
movq -0x58(%rbp), %rdi
callq 0x20ec0
movq -0x60(%rbp), %rdi
callq 0x12c30
movq -0x68(%rbp), %rdi
callq 0x12c30
movq -0x50(%rbp), %rdi
callq 0x12c30
movq -0x38(%rbp), %rdi
callq 0x4570
nopw %cs:(%rax,%rax)