LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/loverszhaokai[P]TypoCheck/src/typo_check.cc
// Function: main
int main(int argc, char **argv)
{
	if (argc != 3) {
		usage();
		return -1;
	}

	cout << "Checking typos, please wait a moment" << endl;

	init();

	init_typos(string(argv[1]));

	print_typo_info();

	search_typo_per_file(string(argv[2]));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %edi
jne 0x246c
movq %rsi, %rbx
movq 0x3bd4(%rip), %rdi      # 0x5fd8
leaq 0x1bf9(%rip), %rsi      # 0x4004
callq 0x2170
movq %rax, %rdi
callq 0x20e0
callq 0x25b4
movq 0x8(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x24d8
leaq -0x30(%rbp), %rdi
callq 0x25ed
leaq -0x30(%rbp), %rdi
callq 0x20d0
callq 0x2b3b
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x24d8
leaq -0x30(%rbp), %rdi
callq 0x28b0
leaq -0x30(%rbp), %rdi
callq 0x20d0
xorl %eax, %eax
jmp 0x24b4
movq 0x3b65(%rip), %rbx      # 0x5fd8
movq %rbx, %rdi
callq 0x20e0
leaq 0x1ba7(%rip), %rsi      # 0x4029
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20e0
leaq 0x1b97(%rip), %rsi      # 0x4030
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x24bf
jmp 0x24cd
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20d0
jmp 0x24d0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: init()
void init()
{
	for (int i = 0; i < sizeof(cidx) / sizeof(char); i++) {
		if (i >= 'a' && i <= 'z')
			cidx[i] = i - 'a';
		else if (i >= 'A' && i <= 'Z')
			cidx[i] = i - 'A';
		else
			cidx[i] = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x3bff(%rip), %rcx      # 0x61c0
cmpq $0x100, %rax            # imm = 0x100
je 0x25eb
leal -0x61(%rax), %edx
cmpl $0x19, %edx
ja 0x25d6
leal -0x61(%rax), %edx
jmp 0x25e3
leal -0x41(%rax), %esi
movb $-0x1, %dl
cmpl $0x19, %esi
ja 0x25e3
leal -0x41(%rax), %edx
movb %dl, (%rax,%rcx)
incq %rax
jmp 0x25c1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: print_typo(TypoInfo*)
static void print_typo(TypoInfo *tip)
{
	words.push_back(tip);

	if (tip->rw != "") {
		cout << "wrong word:'";
		for (int i = 0; i < words.size(); i++) {
			cout << words[i]->ch;
		}
		cout << "' right word:'" << tip->rw << "'" << endl;
	}

	list<TypoInfo>::iterator it;
	for (it = tip->children.begin(); it != tip->children.end(); it++) {
		print_typo(&(*it));
		words.pop_back();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rbp), %rbx
movq %rdi, (%rbx)
leaq 0x375e(%rip), %rdi      # 0x62c0
movq %rbx, %rsi
callq 0x3068
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x155a(%rip), %rsi      # 0x40d2
callq 0x304b
testb %al, %al
je 0x2c06
movq 0x344c(%rip), %rbx      # 0x5fd8
leaq 0x1540(%rip), %rsi      # 0x40d3
movq %rbx, %rdi
callq 0x2170
xorl %r14d, %r14d
movq 0x3723(%rip), %rcx      # 0x62c8
movq 0x3714(%rip), %rax      # 0x62c0
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x2bcc
movq (%rax,%r14,8), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x21b0
incq %r14
jmp 0x2b9e
movq 0x3405(%rip), %rdi      # 0x5fd8
leaq 0x1506(%rip), %rsi      # 0x40e0
callq 0x2170
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x14db(%rip), %rsi      # 0x40d1
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20e0
movq -0x18(%rbp), %rax
leaq 0x48(%rax), %rbx
movq (%rbx), %rbx
addq $0x48, %rax
cmpq %rax, %rbx
je 0x2c31
leaq 0x10(%rbx), %rdi
callq 0x2b49
addq $-0x8, 0x369d(%rip)     # 0x62c8
movq -0x18(%rbp), %rax
jmp 0x2c0e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: TypoInfo::TypoInfo()
TypoInfo()
	{
		ch = ' ';
		ww = "";
		rw = "";
		children = list<TypoInfo>();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r15
movq %r15, 0x50(%rdi)
movq %r15, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
movb $0x20, (%rdi)
leaq 0x1444(%rip), %rsi      # 0x40d2
movq %rbx, %rdi
callq 0x2220
leaq 0x1435(%rip), %rsi      # 0x40d2
movq %r14, %rdi
callq 0x2220
leaq -0x38(%rbp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2d30
movq %rbx, %rdi
callq 0x2d8a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x2d8a
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: TypoInfo::TypoInfo(char, 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&)
TypoInfo(char _ch, const string &_ww, const string &_rw)
	{
		ch = _ch;
		ww = _rw;
		rw = _rw;
		children = list<TypoInfo>();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r12
movq %r12, 0x50(%rdi)
movq %r12, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
movb %sil, (%rdi)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2100
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq -0x38(%rbp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2d30
movq %rbx, %rdi
callq 0x2d8a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x2d8a
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/device_monitor.cpp
// Function: DeviceMonitor::deviceChanged_(udev_device*, bool)
void DeviceMonitor::deviceChanged_( udev_device* device, bool state ) {
	if (!acceptDevice_(device)) return;

	int led_idx = scsiHostIndex_(device);
	if (led_idx < 0) return;
	if (debug) std::cout << " device: " << udev_device_get_syspath(device) << "\n led: " << led_idx << "\n";

	// finally we can play with the appopriate LED
	if ( leds_ ) leds_->Set( LED_BLUE, led_idx, state );
        led_enabled_[led_idx] = state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x5278
testb %al, %al
je 0x546d
movq %r15, %rsi
callq 0x5476
testl %eax, %eax
js 0x546d
movl %eax, %ebp
leaq 0xaf6c(%rip), %rax      # 0x10360
cmpl $0x0, (%rax)
je 0x544a
movq 0xabb0(%rip), %rdi      # 0xffb0
leaq 0x4d0d(%rip), %rsi      # 0xa114
callq 0x42d0
movq %rax, %r12
movq %r15, %rdi
callq 0x4510
movq %r12, %rdi
movq %rax, %rsi
callq 0x42d0
leaq 0x4cf5(%rip), %rsi      # 0xa11e
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x4540
leaq 0x52b1(%rip), %rsi      # 0xa6f3
movq %rax, %rdi
callq 0x42d0
movq 0x10(%r14), %rdi
movl %ebp, %r15d
testq %rdi, %rdi
je 0x5465
movq (%rdi), %rax
movzbl %bl, %ecx
pushq $0x1
popq %rsi
movq %r15, %rdx
callq *0x28(%rax)
movb %bl, 0x168(%r14,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::Stop()
void UpdateMonitor::Stop()
{
	if (!instance_started_)
	{
		if (verbose > 0)
		{
			std::cout << "Update monitor thread already stopped.\n";
		}
		return;
	}
	if (verbose > 0)
	{
		std::cout << "Attempting to stop update monitor thread.\n";
	}
	//Cancelling thread.
	if(pthread_cancel(monitor_thread_) != 0)
	{
		throw ErrnoException("pthread_cancel");
	}
	//Waiting for thread to join.
	if(pthread_join(monitor_thread_, NULL) != 0)
	{
		throw ErrnoException("pthread_join");
	}
	if (verbose > 0)
	{
		std::cout << "Update monitor thread stopped.\n";
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0xa84f(%rip), %r14      # 0x10364
movl (%r14), %eax
cmpb $0x0, 0xa839(%rip)      # 0x10358
je 0x5b68
movq %rdi, %rbx
testl %eax, %eax
jle 0x5b3b
movq 0xa481(%rip), %rdi      # 0xffb0
leaq 0x4891(%rip), %rsi      # 0xa3c7
callq 0x42d0
movq (%rbx), %rdi
callq 0x4440
testl %eax, %eax
jne 0x5b90
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x42a0
testl %eax, %eax
jne 0x5be2
cmpl $0x0, (%r14)
jle 0x5b87
leaq 0x48a8(%rip), %rsi      # 0xa40e
jmp 0x5b73
testl %eax, %eax
jle 0x5b87
leaq 0x482c(%rip), %rsi      # 0xa39f
movq 0xa436(%rip), %rdi      # 0xffb0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x42d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x4850(%rip), %rsi      # 0xa3f2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x9b0f(%rip), %rsi      # 0xf6e0
movq 0xa3c8(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
jmp 0x5c32
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x480d(%rip), %rsi      # 0xa401
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x9abd(%rip), %rsi      # 0xf6e0
movq 0xa376(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
jmp 0x5c36
jmp 0x5c4a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x5c4d
jmp 0x5c55
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::Start()
void UpdateMonitor::Start()
{
	if (instance_started_)
	{
		if (verbose > 0)
		{
			std::cout << "Update monitor thread already running.\n";
		}
		return;
	}
	if (pthread_create(&monitor_thread_, NULL, MonitorThreadProc, NULL) != 0)
	{
		throw ErrnoException("pthread_create");
	}
	instance_started_ = true;
	if (verbose > 0)
	{
		std::cout << "Update monitor thread started.\n";
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpb $0x1, 0xa6eb(%rip)      # 0x10358
jne 0x5c84
leaq 0xa6ee(%rip), %rax      # 0x10364
cmpl $0x0, (%rax)
jle 0x5cc6
leaq 0x46c6(%rip), %rsi      # 0xa348
jmp 0x5cb2
leaq 0xbb(%rip), %rdx        # 0x5d46
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4590
testl %eax, %eax
jne 0x5ccf
movb $0x1, 0xa6b9(%rip)      # 0x10358
leaq 0xa6be(%rip), %rax      # 0x10364
cmpl $0x0, (%rax)
jle 0x5cc6
leaq 0x46cd(%rip), %rsi      # 0xa37f
movq 0xa2f7(%rip), %rdi      # 0xffb0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x42d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x468f(%rip), %rsi      # 0xa370
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x99d0(%rip), %rsi      # 0xf6e0
movq 0xa289(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x5d36
jmp 0x5d3e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::MonitorThreadCleanupHandler(void*)
void UpdateMonitor::MonitorThreadCleanupHandler(void* /*arg*/)
{
	if (verbose > 0)
	{
		std::cout << "Cleaning up after the update monitor thread.\n";
	}
	instance_started_ = false;
	//Reset LED.
	leds_->SetSystemLed(LED_BLUE | LED_RED, false);
}

// Assembly:
pushq %rax
leaq 0xa364(%rip), %rax      # 0x10364
cmpl $0x0, (%rax)
jle 0x6018
movq 0x9fa4(%rip), %rdi      # 0xffb0
leaq 0x441b(%rip), %rsi      # 0xa42e
callq 0x42d0
movb $0x0, 0xa339(%rip)      # 0x10358
movq 0xa322(%rip), %rdi      # 0x10348
movq (%rdi), %rax
movq 0x40(%rax), %rax
pushq $0x3
popq %rsi
xorl %edx, %edx
popq %rcx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/mediasmartserverd.cpp
// Function: init_signals()
void init_signals( ) {
	struct sigaction sa;
	sa.sa_flags = 0;
	sa.sa_handler = &sig_handler;
	sigemptyset( &sa.sa_mask );
	if ( -1 == sigaction(SIGINT,  &sa, 0) ) throw ErrnoException( "sigaction(SIGINT)"  );
	if ( -1 == sigaction(SIGTERM, &sa, 0) ) throw ErrnoException( "sigaction(SIGTERM)" );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq 0x30(%rsp), %rdi
andl $0x0, 0x80(%rdi)
leaq 0x10a(%rip), %rax       # 0x63d4
movq %rax, -0x8(%rdi)
callq 0x43d0
pushq $0x2
popq %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x43f0
cmpl $-0x1, %eax
je 0x6307
pushq $0xf
popq %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x43f0
cmpl $-0x1, %eax
je 0x6359
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x430f(%rip), %rsi      # 0xa628
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x9398(%rip), %rsi      # 0xf6e0
movq 0x9c51(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
jmp 0x63a9
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x42cf(%rip), %rsi      # 0xa63a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x9346(%rip), %rsi      # 0xf6e0
movq 0x9bff(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
jmp 0x63ad
jmp 0x63c1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x63c4
jmp 0x63cc
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/mediasmartserverd.cpp
// Function: GetUdevDeviceAttribute(char const*, char const*, char const*)
const char *GetUdevDeviceAttribute(const char *subsystem, const char *sysname, const char *sysattr) {
	struct udev *udev;
	struct udev_device *device;
	std::string value;

	udev = udev_new();
	if (!udev) throw ErrnoException("udev_new");

	device = udev_device_new_from_subsystem_sysname(udev, subsystem, sysname);
	value = udev_device_get_sysattr_value(device, sysattr);
	value.erase(value.begin(), std::find_if(value.begin(), value.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
	value.erase(std::find_if(value.rbegin(), value.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), value.end());
	//free
	udev_device_unref(device);
	udev_unref(udev);
	
	return strdup(value.c_str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0x43c0
movq %rax, %rbx
testq %rax, %rax
je 0x6509
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4480
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x4430
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x45f0
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rsi
addq %r15, %rsi
movq 0x9b03(%rip), %rdx      # 0xff78
movq %r15, %rdi
callq 0x98d9
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4060
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
addq %rax, %rcx
leaq 0x58(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x50(%rsp), %rdx
movq %rax, (%rdx)
movq 0x9ac7(%rip), %rcx      # 0xff78
leaq 0x30(%rsp), %rdi
callq 0x7225
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movq (%rdi), %rdx
addq 0x8(%rdi), %rdx
callq 0x4060
movq %r14, %rdi
callq 0x4640
movq %rbx, %rdi
callq 0x43a0
leaq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0x45b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4150
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x3ae9(%rip), %rsi      # 0xa004
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x9196(%rip), %rsi      # 0xf6e0
movq 0x9a4f(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x6570
jmp 0x6583
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
jmp 0x6583
jmp 0x6580
jmp 0x6580
jmp 0x6580
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4150
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/mediasmartserverd.cpp
// Function: show_help()
int show_help( ) {
	cout << "Usage: mediasmartserverd [OPTION]...\n"
		<< "     --brightness=X    Set LED brightness (1 to 10)\n"
		<< " -D, --daemon          Detach and run in the background\n"
		<< " -a, --activity        Use the bay lights as disk activity lights\n"
		<< "     --debug           Print debug messages\n"
		<< "     --help            Print help text\n"
		<< " -u  --update-monitor  Use system LED as update notification light\n"
		<< " -v, --verbose         verbose (use twice to be more verbose)\n" 
		<< " -V, --version         Show version number\n" 
	;
	
	return 0;
}

// Assembly:
pushq %rax
movq 0x96ad(%rip), %rdi      # 0xffb0
leaq 0x3ee6(%rip), %rsi      # 0xa7f0
callq 0x42d0
leaq 0x3f00(%rip), %rsi      # 0xa816
movq %rax, %rdi
callq 0x42d0
leaq 0x3f26(%rip), %rsi      # 0xa84b
movq %rax, %rdi
callq 0x42d0
leaq 0x3f50(%rip), %rsi      # 0xa884
movq %rax, %rdi
callq 0x42d0
leaq 0x3f84(%rip), %rsi      # 0xa8c7
movq %rax, %rdi
callq 0x42d0
leaq 0x3fa2(%rip), %rsi      # 0xa8f4
movq %rax, %rdi
callq 0x42d0
leaq 0x3fbb(%rip), %rsi      # 0xa91c
movq %rax, %rdi
callq 0x42d0
leaq 0x3ff0(%rip), %rsi      # 0xa960
movq %rax, %rdi
callq 0x42d0
leaq 0x4020(%rip), %rsi      # 0xa99f
movq %rax, %rdi
callq 0x42d0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_acerh340.h
// Function: LedAcerH340::SetSystemLed(int, LedState)
virtual void SetSystemLed( int led_type, LedState state ) {
		const bool on_off_state = ( LED_ON == state );
		if ( led_type & LED_BLUE ) setGpLpcLvl_( OUT_SYSTEM_BLUE, !on_off_state );
		if ( led_type & LED_RED  ) setGpLpcLvl_( OUT_SYSTEM_RED,  !on_off_state );
		
		const bool blink_state  = ( LED_BLINK == state );
		int val = 0;
		if ( led_type & LED_BLUE ) val |= 1 << OUT_SYSTEM_BLUE;
		if ( led_type & LED_RED  ) val |= 1 << OUT_SYSTEM_RED;
		if ( val ) doBits_( val, io_lpc_gpiobase_ + GPO_BLINK, blink_state );
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
andl $0x1, %r15d
je 0x79f2
xorl %edx, %edx
cmpl $0x2, %ebp
setne %dl
pushq $0x14
popq %rsi
movq %r14, %rdi
callq 0x82ca
andl $0x2, %ebx
je 0x7a0a
xorl %edx, %edx
cmpl $0x2, %ebp
setne %dl
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x82ca
shll $0x14, %r15d
shll $0x17, %ebx
orl %r15d, %ebx
je 0x7a39
xorl %ecx, %ecx
cmpl $0x4, %ebp
sete %cl
movl 0x8(%r14), %edx
addl $0x18, %edx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82ea
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::Init()
virtual bool Init( ) {
		if ( !initPciLpc_( )  ) return false;
		if ( !initSch5127_( ) ) return false;
		
		disableWatchDog_( );
		
		return true;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7a84
testb %al, %al
je 0x7a7f
movq %rbx, %rdi
callq 0x7c5a
testb %al, %al
je 0x7a7f
movq %rbx, %rdi
callq 0x7f82
movb $0x1, %al
jmp 0x7a81
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::disableWatchDog_()
void disableWatchDog_( ) {
		// watchdog registers to zero out
		const int WDT_REGS[] = { REG_WDT_VAL, REG_WDT_TIME_OUT, REG_WDT_CFG, REG_WDT_CTRL };
		const size_t WDT_REGS_CNT = sizeof(WDT_REGS) / sizeof(WDT_REGS[0]);
		
		// determine the I/O range of those registers
		const int reg_min = *std::min_element( WDT_REGS, WDT_REGS + WDT_REGS_CNT );
		const int reg_max = *std::max_element( WDT_REGS, WDT_REGS + WDT_REGS_CNT );
		const int reg_cnt = reg_max - reg_min + 1;
		
		// get access to the entire range
		if ( ioperm(io_sch5127_regs_ + reg_min, reg_cnt, 1) ) throw ErrnoException("ioperm");
		
		// zero them out
		for ( size_t i = 0; i < WDT_REGS_CNT; ++i ) {
			outb( 0, io_sch5127_regs_ + WDT_REGS[i] );
		}
		
		// done
		ioperm(io_sch5127_regs_ + reg_min, reg_cnt, 0);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %edi
addl $0x65, %edi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x44e0
testl %eax, %eax
jne 0x7fd7
movl 0xc(%rbx), %edi
leaq 0x2e84(%rip), %rcx      # 0xae30
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x7fc2
movl (%rsi,%rcx), %edx
addl %edi, %edx
xorl %eax, %eax
outb %al, %dx
addq $0x4, %rsi
jmp 0x7fae
addl $0x65, %edi
pushq $0x4
popq %rsi
xorl %edx, %edx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x44e0
pushq $0x10
popq %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x2b21(%rip), %rsi      # 0xab0a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5694
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x56d0
xorl %ebp, %ebp
leaq 0x76c8(%rip), %rsi      # 0xf6e0
movq 0x7f81(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4530
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x803e
jmp 0x8046
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::setGpLpcLvl_(int, bool)
void setGpLpcLvl_( int bit, bool state ) {
		doBits_(
			(1 << (bit % 32)),
			io_lpc_gpiobase_ + ((bit < 32) ? GP_LVL : GP_LVL2),
			state
		);
	}

// Assembly:
movl %edx, %eax
movl %esi, %ecx
pushq $0x1
popq %rsi
shll %cl, %esi
cmpl $0x20, %ecx
pushq $0xc
popq %rcx
pushq $0x38
popq %rdx
cmovll %ecx, %edx
addl 0x8(%rdi), %edx
movl %eax, %ecx
jmp 0x82ea
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::setGpRegsLvl_(int, bool)
void setGpRegsLvl_( int bit, bool state ) {
		const int reg = ((bit >> 4) & 0xF) - 1;
		assert( reg >= 0 );
		
		doBits_(
			(1 << (bit & 0xF)),
			io_sch5127_regs_ + REG_GP1 + reg,
			state
		);
	}

// Assembly:
movl %esi, %r8d
shrl $0x4, %r8d
andl $0xf, %r8d
je 0x832f
andb $0xf, %sil
pushq $0x1
popq %rax
movl %esi, %ecx
shll %cl, %eax
movl 0xc(%rdi), %ecx
addl %ecx, %r8d
addl $0x4a, %r8d
movzbl %dl, %ecx
movl %eax, %esi
movl %r8d, %edx
jmp 0x82ea
pushq %rax
leaq 0x2827(%rip), %rdi      # 0xab5e
leaq 0x2829(%rip), %rsi      # 0xab67
leaq 0x2841(%rip), %rcx      # 0xab86
movl $0x11a, %edx            # imm = 0x11A
callq 0x41d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/merelin[P]mediasmartserverd/src/led_hpex485.h
// Function: LedHpEx48X::enableLeds_()
void enableLeds_( ) {
		// work out which bits we need
		int bits1 = 0, bits2 = 0;
		for ( size_t i = 0; i < MAX_HDD_LEDS; ++i ) {
			setBit32_( ioLedBlue_( i ), bits1, bits2 );
			setBit32_( ioLedRed_( i ),  bits1, bits2 );
		}
		setBit32_( OUT_USB_DEVICE,  bits1, bits2 );
		setBit32_( OUT_SYSTEM_BLUE, bits1, bits2 );
		setBit32_( OUT_SYSTEM_RED,  bits1, bits2 );
		
		setGpioSelInput_( bits1, bits2 );
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x9859
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9876
cmpl $0x20, %eax
movl %ebp, %r12d
cmovll %r14d, %r12d
btsl %eax, %r12d
cmpl $0x20, %eax
cmovll %r12d, %r14d
cmovll %ebp, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98a8
cmpl $0x20, %eax
movl %r12d, %ebp
cmovll %r14d, %ebp
btsl %eax, %ebp
cmpl $0x20, %eax
cmovll %ebp, %r14d
cmovll %r12d, %ebp
incq %r15
jmp 0x9807
orl $0x18000080, %r14d      # imm = 0x18000080
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x805a
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: testPop(char const*, char const*, unsigned long, net::IOBuffer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPop(const char *module, const char *msg, size_t const size, Buffer &b, std::string &s, bool const expect = true){
	bool const result = b.pop(size);

	if (expect)
		s.erase(0, size);

	PRINTF_TEST(msg, result == expect);

	if (s.empty()){
		PRINTF_TEST("size zero",	b.size() == 0				);
	}else{
		PRINTF_TEST("value",		s.compare(0, s.size(), b.data()) == 0	);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r13
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x14d2
movl %eax, %ebx
testl %ebp, %ebp
je 0x1293
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1050
xorb %bpl, %bl
leaq 0xd82(%rip), %r14       # 0x201f
leaq 0xd78(%rip), %rbx       # 0x201c
movq %rbx, %rcx
cmovneq %r14, %rcx
leaq 0xd52(%rip), %rdi       # 0x2004
movq %r13, %rsi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1030
movq 0x8(%r15), %rdx
movq (%r12), %rcx
testq %rdx, %rdx
je 0x12ea
addq 0x8(%r12), %rcx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1080
testl %eax, %eax
sete %al
leaq 0xd3c(%rip), %rdx       # 0x2024
jmp 0x12f9
cmpq %rcx, 0x10(%r12)
sete %al
leaq 0xd31(%rip), %rdx       # 0x202a
testb %al, %al
cmovneq %rbx, %r14
leaq 0xcfe(%rip), %rdi       # 0x2004
movq %r13, %rsi
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: test(char const*)
void test(const char *module = "iobuffer"){
	Buffer b;

	std::string s;

	testPush(module, "push",		"aaa",	b, s);
	testPush(module, "push zero",		"",	b, s, false);
	testPush(module, "push",		"bbb",	b, s);
	testPush(module, "push",		"ccc",	b, s);

	testPop( module, "pop",			3,	b, s);
	testPop( module, "pop zero",		0,	b, s, false);
	testPop( module, "pop",			3,	b, s);
	testPop( module, "pop",			3,	b, s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
andq $0x0, -0x8(%rbx)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xcd6(%rip), %rsi       # 0x2034
leaq 0xcd4(%rip), %rdx       # 0x2039
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
callq 0x11ac
leaq 0xcc0(%rip), %rsi       # 0x203d
leaq 0xc97(%rip), %rdx       # 0x201b
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x11ac
leaq 0xc96(%rip), %rsi       # 0x2034
leaq 0xca2(%rip), %rdx       # 0x2047
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x11ac
leaq 0xc74(%rip), %rsi       # 0x2034
leaq 0xc84(%rip), %rdx       # 0x204b
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x11ac
leaq 0xc6d(%rip), %rsi       # 0x204f
pushq $0x3
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x1257
leaq 0xc53(%rip), %rsi       # 0x2053
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %r14, %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x1257
leaq 0xc33(%rip), %rsi       # 0x204f
pushq $0x3
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x1257
leaq 0xc15(%rip), %rsi       # 0x204f
pushq $0x3
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x1257
movq %rsp, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1070
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/dm4[P]huffman-homework/decode.cc
// Function: calcBase(int, char*)
int calcBase(int height, char *codeword) {
    unsigned int mask = 1 << 3;
    int sum = 0;
    for (int i = height - 4; codeword[i]; i++) {
        if (codeword[i] == '1')
            sum += mask;
        mask >>= 1;
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl $-0x4, %edi
movslq %edi, %rcx
addq %rsi, %rcx
xorl %eax, %eax
movl $0x8, %edx
movzbl (%rcx), %esi
cmpl $0x31, %esi
je 0x13d3
testl %esi, %esi
jne 0x13d5
jmp 0x13dc
addl %edx, %eax
shrl %edx
incq %rcx
jmp 0x13c5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dm4[P]huffman-homework/decode.cc
// Function: bin2dec(int, int, char*)
int bin2dec(int from, int to, char *codeword) {
    unsigned int mask = 1 << (to - from - 1);
    int sum = 0;
    for (int i = from; i < to; i++) {
        if (codeword[i] == '1')
            sum += mask;
        mask >>= 1;
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %r8
notl %edi
leal (%rdi,%rsi), %ecx
movl $0x1, %edi
shll %cl, %edi
movslq %esi, %rcx
xorl %eax, %eax
cmpq %rcx, %r8
jge 0x1411
cmpb $0x31, (%rdx,%r8)
movl $0x0, %esi
cmovel %edi, %esi
addl %esi, %eax
shrl %edi
incq %r8
jmp 0x13f6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dm4[P]huffman-homework/decode.cc
// Function: print_codeword(char*)
void print_codeword(char *codeword) {
    for (int i = 0; codeword[i]; i++) {
        if (i % 4 == 0)
            putchar(' ');
        putchar(codeword[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x20
popq %r14
movb (%rbx,%r15), %al
testb %al, %al
je 0x144e
testb $0x3, %r15b
jne 0x1441
movl %r14d, %edi
callq 0x1160
movb (%rbx,%r15), %al
movsbl %al, %edi
callq 0x1160
incq %r15
jmp 0x1427
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dm4[P]huffman-homework/decode.cc
// Function: alignBuf(char*)
void alignBuf(char buf[5]) {
    int index = 0;
    int num = 0;
    for (int i = 0; i < 4; i++) {
        if (buf[i]) {
            buf[index++] = buf[i];
            num++;
        }
    }
    for (int i = num; i < 4; i++) {
        buf[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
cmpq $0x4, %rax
je 0x1482
movb (%rdi,%rax), %sil
testb %sil, %sil
je 0x147d
movslq %edx, %r8
incl %edx
movb %sil, (%rdi,%r8)
incl %ecx
incq %rax
jmp 0x1463
movslq %ecx, %rax
cmpq $0x4, %rax
jge 0x1494
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x1485
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::Graph(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
Graph::Graph(vector<vector<int> >& c_nodes) {
  nb_nodes     = 0;
  nb_links     = 0;
  total_weight = 0;
  
  nodes.reserve(c_nodes.size());
  for (size_t i=0; i<c_nodes.size(); i++) {
    nodes.push_back(c_nodes[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
andl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %r12
cqto
idivq %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x2d80
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %rbp
jae 0x27a7
addq %r13, %rsi
movq %r14, %rdi
callq 0x2c94
incq %rbp
addq $0x18, %r13
jmp 0x277f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27b8
movq %rax, %r15
leaq 0x60(%rbx), %rdi
leaq 0x48(%rbx), %r12
addq $0x18, %rbx
callq 0x2f90
movq %r12, %rdi
callq 0x2f5c
movq %r14, %rdi
callq 0x2d5e
movq %rbx, %rdi
callq 0x2ec6
movq %r15, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display()
void
Graph::display() {
  /*
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    cout << node << ":" ;
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (true) {
	if (weights.size()!=0)
	  cout << " (" << *(p.first+i) << " " << *(p.second+i) << ")";
	else
	  cout << " " << *(p.first+i);
      }
    }
    cout << endl;
  }
  */
  for (size_t i=0; i<nodes.size(); i++) {
    for (size_t j=0; j<nodes[i].size(); j++) {
      cout << nodes[i][j] << " ";  
    }
    cout << "\n";  
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0x87c2(%rip), %r14      # 0xafd0
leaq 0x4eb2(%rip), %r15      # 0x76c7
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rax, %r13
jae 0x287d
imulq $0x18, %r13, %rbp
xorl %r12d, %r12d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jae 0x2869
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x22d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
incq %r12
movq 0x30(%rbx), %rcx
jmp 0x2834
movq %r14, %rdi
leaq 0x4e26(%rip), %rsi      # 0x7699
callq 0x2180
incq %r13
jmp 0x2815
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::write_community(char const*)
void
Graph::write_community(const char *filename_w) {
  FILE* fOut = fopen(filename_w, "wt");
  for (size_t i=0; i<nodes.size(); i++) {
    for (size_t j=0; j<nodes[i].size(); j++) {
      fprintf(fOut, "%d ", nodes[i][j]);  
    }
    fprintf(fOut, "\n");  
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x47d0(%rip), %rsi      # 0x7074
movq %rax, %rdi
callq 0x21d0
movq %rax, %r14
leaq 0x47c1(%rip), %r15      # 0x7077
xorl %r13d, %r13d
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rax, %r13
jae 0x2915
imulq $0x18, %r13, %r12
xorl %ebp, %ebp
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rbp
jae 0x2905
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2230
incq %rbp
movq 0x30(%rbx), %rcx
jmp 0x28d7
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x2200
incq %r13
jmp 0x28b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display_reverse()
void
Graph::display_reverse() {
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (node>*(p.first+i)) {
	if (weights.size()!=0)
	  cout << *(p.first+i) << " " << node << " " << *(p.second+i) << endl;
	else
	  cout << *(p.first+i) << " " << node << endl;
      }
    }   
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movl (%rbx), %eax
cmpq %rax, %r14
jae 0x29ea
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2e22
movq %rax, %r12
movq %rdx, 0x8(%rsp)
xorl %r15d, %r15d
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2e7c
movl %eax, %eax
cmpq %rax, %r15
jae 0x29e2
movl (%r12,%r15,4), %esi
cmpq %rsi, %r14
jbe 0x29da
movq 0x68(%rbx), %r12
movq 0x60(%rbx), %rbp
movq 0x8648(%rip), %rdi      # 0xafd0
callq 0x2100
movq %rax, %rdi
leaq 0x4d30(%rip), %r13      # 0x76c7
movq %r13, %rsi
callq 0x2180
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
cmpq %rbp, %r12
je 0x29cd
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movq 0x8(%rsp), %rcx
movss (%rcx,%r15,4), %xmm0
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20c0
movq 0x10(%rsp), %r12
incq %r15
jmp 0x295e
incq %r14
jmp 0x2938
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::check_symmetry()
bool
Graph::check_symmetry() {
  int error=0;
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      unsigned int neigh = *(p.first+i);
      float weight = *(p.second+i);
      
      pair<vector<unsigned int>::iterator, vector<float>::iterator > p_neigh = neighbors(neigh);
      for (unsigned int j=0 ; j<nb_neighbors(neigh) ; j++) {
	unsigned int neigh_neigh = *(p_neigh.first+j);
	float neigh_weight = *(p_neigh.second+j);

	if (node==neigh_neigh && weight!=neigh_weight) {
	  cout << node << " " << neigh << " " << weight << " " << neigh_weight << endl;
	  if (error++==10)
	    exit(0);
	}
      }
    }
  }
  return (error==0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %rdi, 0x10(%rsp)
movl (%rbx), %eax
cmpq %rax, %r14
jae 0x2b5c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2e22
movq %rax, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2e7c
movl %eax, %eax
cmpq %rax, %r15
jae 0x2b54
movq 0x20(%rsp), %rax
movl (%rax,%r15,4), %r13d
movq 0x18(%rsp), %rax
movq %r15, 0x28(%rsp)
movss (%rax,%r15,4), %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2e22
movq %rax, %rbp
movq %rdx, 0x30(%rsp)
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
movl %r13d, %esi
callq 0x2e7c
movl %eax, %eax
cmpq %rax, %rbx
jae 0x2b42
movl (%rbp,%rbx,4), %eax
cmpq %rax, %r14
jne 0x2b3a
movq 0x30(%rsp), %rax
movss (%rax,%rbx,4), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x2abf
jnp 0x2b3a
movq 0x850a(%rip), %rdi      # 0xafd0
movq %r14, %rsi
movss %xmm0, 0xc(%rsp)
callq 0x2100
movq %rax, %rdi
movl %r12d, %r15d
leaq 0x4be6(%rip), %r12      # 0x76c7
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
movq %r13, %rsi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
movss 0x8(%rsp), %xmm0
callq 0x2120
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %r12d
callq 0x2180
movq %rax, %rdi
movss 0xc(%rsp), %xmm0
callq 0x2120
movq %rax, %rdi
callq 0x20c0
cmpl $0xa, %r15d
je 0x2b71
incl %r12d
incq %rbx
jmp 0x2a83
movq 0x28(%rsp), %r15
incq %r15
movq 0x10(%rsp), %rbx
jmp 0x2a39
incq %r14
jmp 0x2a16
testl %r12d, %r12d
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display_binary(char*)
void
Graph::display_binary(char *outfile) {
  ofstream foutput;
  foutput.open(outfile ,fstream::out | fstream::binary);

  foutput.write((char *)(&nb_nodes),4);
  foutput.write((char *)(&degrees[0]),4*nb_nodes);
  foutput.write((char *)(&links[0]),8*nb_links);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x22c0
pushq $0x14
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2030
movq %rsp, %rdi
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x2220
movq 0x18(%rbx), %rsi
movl (%rbx), %edx
shll $0x2, %edx
movq %rsp, %rdi
callq 0x2220
movq 0x8(%rbx), %rdx
movq 0x48(%rbx), %rsi
shlq $0x3, %rdx
movq %rsp, %rdi
callq 0x2220
movq %rsp, %rdi
callq 0x2260
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::weighted_degree(unsigned int)
inline double
Graph::weighted_degree(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (weights.size()==0)
    return (double)nb_neighbors(node);
  else {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    double res = 0;
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      res += (double)*(p.second+i);
    }
    return res;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl %esi, (%rdi)
jbe 0x2d41
movl %esi, %ebx
movq %rdi, %r14
movq 0x68(%rdi), %rax
cmpq 0x60(%rdi), %rax
je 0x2d24
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e22
movq %rdx, %r15
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e7c
movl %eax, %eax
cmpq %rax, %r12
jae 0x2d1d
cvtss2sd (%r15,%r12,4), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
jmp 0x2cf3
movsd (%rsp), %xmm0
jmp 0x2d35
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e7c
movl %eax, %eax
cvtsi2sd %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4333(%rip), %rdi      # 0x707b
leaq 0x4345(%rip), %rsi      # 0x7094
leaq 0x434f(%rip), %rcx      # 0x70a5
pushq $0x74
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::neighbors(unsigned int)
inline pair<vector<unsigned int>::iterator, vector<float>::iterator >
Graph::neighbors(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (node==0)
    return make_pair(links.begin(), weights.begin());
  else if (weights.size()!=0)
    return make_pair(links.begin()+degrees[node-1], weights.begin()+degrees[node-1]);
  else
    return make_pair(links.begin()+degrees[node-1], weights.begin());
}

// Assembly:
cmpl %esi, (%rdi)
jbe 0x2e5c
testl %esi, %esi
je 0x2e53
movq 0x18(%rdi), %rax
decl %esi
movq (%rax,%rsi,8), %rcx
leaq (,%rcx,4), %rax
addq 0x48(%rdi), %rax
movq 0x60(%rdi), %rdx
xorl %esi, %esi
cmpq %rdx, 0x68(%rdi)
cmovneq %rcx, %rsi
leaq (%rdx,%rsi,4), %rdx
retq
movq 0x48(%rdi), %rax
movq 0x60(%rdi), %rdx
retq
pushq %rax
leaq 0x4217(%rip), %rdi      # 0x707b
leaq 0x4229(%rip), %rsi      # 0x7094
leaq 0x425f(%rip), %rcx      # 0x70d1
movl $0x84, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::nb_neighbors(unsigned int)
inline unsigned int
Graph::nb_neighbors(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (node==0)
    return degrees[0];
  else
    return degrees[node]-degrees[node-1];
}

// Assembly:
cmpl %esi, (%rdi)
jbe 0x2e9d
testl %esi, %esi
je 0x2e95
movl %esi, %eax
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rax
decl %esi
subq (%rcx,%rsi,8), %rax
retq
movq 0x18(%rdi), %rax
movq (%rax), %rax
retq
pushq %rax
leaq 0x41d6(%rip), %rdi      # 0x707b
leaq 0x41e8(%rip), %rsi      # 0x7094
leaq 0x427b(%rip), %rcx      # 0x712e
pushq $0x5a
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/community.cpp
// Function: Community::Community(char*, char*, int, int, double)
Community::Community(char * filename, char * filename_w, int type, int nbp, double minm) {
  g = Graph(filename, filename_w, type);
  size = g.nb_nodes;

  neigh_weight.resize(size,-1);
  neigh_pos.resize(size);
  neigh_last=0;

  n2c.resize(size);
  in.resize(size);
  tot.resize(size);

  for (int i=0 ; i<size ; i++) {
    n2c[i] = i;
    tot[i] = g.weighted_degree(i);
    in[i]  = g.nb_selfloops(i);
  }

  nb_pass = nbp;
  min_modularity = minm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movsd %xmm0, 0x10(%rsp)
movl %r8d, (%rsp)
movl %ecx, 0x4(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r15, %rdi
callq 0x247c
leaq 0xb8(%rbx), %r12
leaq 0xd0(%rbx), %r13
leaq 0xe8(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
andq $0x0, 0xf8(%rbx)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq 0x18(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x24a0
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x48ea
movq %r14, %rdi
callq 0x4944
movslq 0x38(%rbx), %rsi
movl %esi, 0xb0(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%r14)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x4970
movslq 0xb0(%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x2c30
andl $0x0, 0x30(%rbx)
movslq 0xb0(%rbx), %rsi
movq %r12, %rdi
callq 0x49a4
movslq 0xb0(%rbx), %rsi
movq %r13, %rdi
callq 0x49d6
movslq 0xb0(%rbx), %rsi
movq %rbp, %rdi
callq 0x49d6
xorl %r14d, %r14d
movslq 0xb0(%rbx), %rax
cmpq %rax, %r14
jge 0x3a7f
movq (%r12), %rax
movl %r14d, (%rax,%r14,4)
movq %r15, %rdi
movl %r14d, %esi
callq 0x2cc0
movq (%rbp), %rax
movsd %xmm0, (%rax,%r14,8)
movq %r15, %rdi
movl %r14d, %esi
callq 0x4a08
movq (%r13), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x3a3c
movl (%rsp), %eax
movl %eax, 0x100(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x108(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ab3
jmp 0x3ab3
movq %rax, %r14
jmp 0x3ad6
jmp 0x3ab3
movq %rax, %r14
movq %rbp, %rdi
callq 0x563c
movq %r13, %rdi
callq 0x563c
movq %r12, %rdi
callq 0x34f2
movq %r15, %rdi
callq 0x4944
movq 0x8(%rsp), %rdi
callq 0x2f5c
movq %rbx, %rdi
callq 0x563c
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/community.cpp
// Function: Community::Community(Graph, int, double)
Community::Community(Graph gc, int nbp, double minm) {
  g = gc;
  size = g.nb_nodes;

  neigh_weight.resize(size,-1);
  neigh_pos.resize(size);
  neigh_last=0;

  n2c.resize(size);
  in.resize(size);
  tot.resize(size);

  for (int i=0 ; i<size ; i++) {
    n2c[i] = i;
    in[i]  = g.nb_selfloops(i);
    tot[i] = g.weighted_degree(i);
  }

  nb_pass = nbp;
  min_modularity = minm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r15, %rdi
callq 0x247c
leaq 0xb8(%rbx), %r12
leaq 0xd0(%rbx), %r13
leaq 0xe8(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
andq $0x0, 0xf8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a8c
movslq 0x38(%rbx), %rsi
movl %esi, 0xb0(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0x4970
movslq 0xb0(%rbx), %rsi
movq 0x10(%rsp), %rdi
callq 0x2c30
andl $0x0, 0x30(%rbx)
movslq 0xb0(%rbx), %rsi
movq %r12, %rdi
callq 0x49a4
movslq 0xb0(%rbx), %rsi
movq %r13, %rdi
callq 0x49d6
movslq 0xb0(%rbx), %rsi
movq %rbp, %rdi
callq 0x49d6
xorl %r14d, %r14d
movslq 0xb0(%rbx), %rax
cmpq %rax, %r14
jge 0x3c24
movq (%r12), %rax
movl %r14d, (%rax,%r14,4)
movq %r15, %rdi
movl %r14d, %esi
callq 0x4a08
movq (%r13), %rax
movsd %xmm0, (%rax,%r14,8)
movq %r15, %rdi
movl %r14d, %esi
callq 0x2cc0
movq (%rbp), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x3be1
movl 0xc(%rsp), %eax
movl %eax, 0x100(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x108(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c54
movq %rax, %r14
jmp 0x3c77
jmp 0x3c54
movq %rax, %r14
movq %rbp, %rdi
callq 0x563c
movq %r13, %rdi
callq 0x563c
movq %r12, %rdi
callq 0x34f2
movq %r15, %rdi
callq 0x4944
movq 0x10(%rsp), %rdi
callq 0x2f5c
movq %rbx, %rdi
callq 0x563c
movq %r14, %rdi
callq 0x22f0
nop