LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x2b1d
cmpl $0x61, -0x4(%rbp)
jl 0x2adb
cmpl $0x7a, -0x4(%rbp)
jg 0x2adb
movl -0x4(%rbp), %eax
subl $0x61, %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x677a(%rip), %rax      # 0x9250
movb %dl, (%rax,%rcx)
jmp 0x2b10
cmpl $0x41, -0x4(%rbp)
jl 0x2aff
cmpl $0x5a, -0x4(%rbp)
jg 0x2aff
movl -0x4(%rbp), %eax
subl $0x41, %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x6756(%rip), %rax      # 0x9250
movb %dl, (%rax,%rcx)
jmp 0x2b0e
movslq -0x4(%rbp), %rcx
leaq 0x6746(%rip), %rax      # 0x9250
movb $-0x1, (%rax,%rcx)
jmp 0x2b10
jmp 0x2b12
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2aab
popq %rbp
retq
nop
// File: loverszhaokai[P]TypoCheck/src/typo.cc
// Function: search_typo_per_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int search_typo_per_file(const string &file)
{
	fstream fs;

	fs.open(file.c_str(), fstream::in);

	if (!fs.is_open()) {
		cout << "failed to read typos file[" << file << "]" << endl;
		return -1;
	}

	string line;
	size_t index;

	while (getline(fs, line)) {
		search_typo_per_line(line);
	}

	fs.close();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x2270
movq -0x10(%rbp), %rdi
callq 0x20d0
movq -0x260(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x21b0
jmp 0x3181
leaq -0x220(%rbp), %rdi
callq 0x2300
movb %al, -0x261(%rbp)
jmp 0x3195
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x3238
jmp 0x31a5
movq 0x5e2c(%rip), %rdi      # 0x8fd8
leaq 0x2ec5(%rip), %rsi      # 0x6078
callq 0x21c0
movq %rax, -0x270(%rbp)
jmp 0x31c1
movq -0x270(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq %rax, -0x278(%rbp)
jmp 0x31da
movq -0x278(%rbp), %rdi
leaq 0x2eab(%rip), %rsi      # 0x6093
callq 0x21c0
movq %rax, -0x280(%rbp)
jmp 0x31f6
movq -0x280(%rbp), %rdi
movq 0x5dc4(%rip), %rsi      # 0x8fc8
callq 0x2200
jmp 0x320b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x230(%rbp)
jmp 0x32e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x32fd
leaq -0x250(%rbp), %rdi
callq 0x22b0
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2070
movq %rax, -0x288(%rbp)
jmp 0x3260
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2290
movb %al, -0x289(%rbp)
jmp 0x327e
movb -0x289(%rbp), %al
testb $0x1, %al
jne 0x328a
jmp 0x32ba
leaq -0x250(%rbp), %rdi
callq 0x3320
jmp 0x3298
jmp 0x3244
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2120
jmp 0x32fd
leaq -0x220(%rbp), %rdi
callq 0x2040
jmp 0x32c8
movl $0x0, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2120
leaq -0x220(%rbp), %rdi
callq 0x2080
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x2080
movq -0x228(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5c8d(%rip), %rdi      # 0x9350
leaq -0x8(%rbp), %rsi
callq 0x47c0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq 0x29df(%rip), %rsi      # 0x60ba
callq 0x46b0
testb $0x1, %al
jne 0x36e9
jmp 0x3791
movq 0x58e8(%rip), %rdi      # 0x8fd8
leaq 0x29c4(%rip), %rsi      # 0x60bb
callq 0x21c0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x5c3e(%rip), %rdi      # 0x9350
callq 0x4830
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3750
movslq -0xc(%rbp), %rsi
leaq 0x5c22(%rip), %rdi      # 0x9350
callq 0x4850
movq (%rax), %rax
movq 0x589b(%rip), %rdi      # 0x8fd8
movsbl (%rax), %esi
callq 0x2260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3703
movq 0x5881(%rip), %rdi      # 0x8fd8
leaq 0x296a(%rip), %rsi      # 0x60c8
callq 0x21c0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x293c(%rip), %rsi      # 0x60b9
callq 0x21c0
movq %rax, %rdi
movq 0x583c(%rip), %rsi      # 0x8fc8
callq 0x2200
leaq -0x18(%rbp), %rdi
callq 0x3ef0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x3f10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x3f70
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3f40
testb $0x1, %al
jne 0x37d7
jmp 0x3805
leaq -0x18(%rbp), %rdi
callq 0x4140
movq %rax, %rdi
callq 0x36b0
leaq 0x5b61(%rip), %rdi      # 0x9350
callq 0x4870
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3fc0
movq %rax, -0x30(%rbp)
jmp 0x37b3
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: loverszhaokai[P]TypoCheck/src/typo.cc
// Function: TypoInfo::TypoInfo()
TypoInfo()
	{
		ch = ' ';
		ww = "";
		rw = "";
		children = list<TypoInfo>();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0x39b0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movb $0x20, (%rax)
leaq 0x2855(%rip), %rsi      # 0x60ba
callq 0x22a0
jmp 0x386c
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
leaq 0x283f(%rip), %rsi      # 0x60ba
callq 0x22a0
jmp 0x3882
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x39b0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
leaq -0x30(%rbp), %rsi
callq 0x39d0
leaq -0x30(%rbp), %rdi
callq 0x3a00
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a00
movq -0x50(%rbp), %rdi
callq 0x2120
movq -0x38(%rbp), %rdi
callq 0x2120
movq -0x10(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x22b0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0x22b0
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x39b0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movb -0x9(%rbp), %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rsi
callq 0x2030
jmp 0x40b9
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rdi
callq 0x2030
jmp 0x40cc
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
leaq -0x48(%rbp), %rdi
callq 0x39b0
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
leaq -0x48(%rbp), %rsi
callq 0x39d0
leaq -0x48(%rbp), %rdi
callq 0x3a00
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3a00
movq -0x68(%rbp), %rdi
callq 0x2120
movq -0x50(%rbp), %rdi
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6ed0
testb $0x1, %al
jne 0x70a1
jmp 0x716d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7180
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x70bc
jmp 0x716d
leaq 0x11355(%rip), %rax     # 0x18418
cmpl $0x0, (%rax)
je 0x711d
movq 0x10ee1(%rip), %rdi     # 0x17fb0
leaq 0xb03e(%rip), %rsi      # 0x12114
callq 0x5380
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5650
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5380
movq %rax, %rdi
leaq 0xb020(%rip), %rsi      # 0x1211e
callq 0x5380
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x5690
movq %rax, %rdi
leaq 0xb6b7(%rip), %rsi      # 0x127cf
callq 0x5380
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x7850
cmpq $-0x1, %rax
je 0x7158
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x7880
movq %rax, %rdi
movslq -0x18(%rbp), %rdx
movb -0x11(%rbp), %cl
movq (%rdi), %rax
movl $0x1, %esi
andb $0x1, %cl
movzbl %cl, %ecx
callq *0x28(%rax)
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %dl
movslq -0x18(%rbp), %rcx
andb $0x1, %dl
movb %dl, 0x168(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0xfbb5(%rip)      # 0x18410
je 0x8881
leaq 0xfbb8(%rip), %rax      # 0x1841c
cmpl $0x0, (%rax)
jle 0x887c
movq 0xf740(%rip), %rdi      # 0x17fb0
leaq 0x9ad1(%rip), %rsi      # 0x12348
callq 0x5380
jmp 0x896e
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xf0(%rip), %rdx        # 0x8980
movq %rcx, %rsi
callq 0x5700
cmpl $0x0, %eax
je 0x8948
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x51b0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x56c0
movq -0x50(%rbp), %rdx
leaq 0x9aa5(%rip), %rsi      # 0x12370
leaq -0x28(%rbp), %rdi
callq 0x7600
jmp 0x88d6
callq 0x5030
movq -0x58(%rbp), %rdi
movl (%rax), %edx
leaq -0x28(%rbp), %rsi
callq 0x76b0
jmp 0x88ec
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0xed05(%rip), %rsi      # 0x17600
leaq -0x1182(%rip), %rdx     # 0x7780
callq 0x5680
jmp 0x897d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x892c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5230
leaq -0x29(%rbp), %rdi
callq 0x53f0
testb $0x1, -0x3d(%rbp)
jne 0x893d
jmp 0x8946
movq -0x58(%rbp), %rdi
callq 0x52a0
jmp 0x8974
movb $0x1, 0xfac1(%rip)      # 0x18410
leaq 0xfac6(%rip), %rax      # 0x1841c
cmpl $0x0, (%rax)
jle 0x896e
movq 0xf64e(%rip), %rdi      # 0x17fb0
leaq 0x9a16(%rip), %rsi      # 0x1237f
callq 0x5380
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf579(%rip), %rax      # 0x1841c
cmpl $0x0, (%rax)
jle 0x8ebb
movq 0xf101(%rip), %rdi      # 0x17fb0
leaq 0x9578(%rip), %rsi      # 0x1242e
callq 0x5380
movb $0x0, 0xf54e(%rip)      # 0x18410
leaq 0xf537(%rip), %rdi      # 0x18400
callq 0x7880
movq %rax, %rdi
movq (%rdi), %rax
movl $0x3, %esi
xorl %edx, %edx
callq *0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x10(%rbp)
leaq 0x237(%rip), %rax       # 0x9540
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x54f0
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5510
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x9427
movb $0x1, -0xcd(%rbp)
movl $0x10, %edi
callq 0x51b0
movq %rax, -0x108(%rbp)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x56c0
movq -0x100(%rbp), %rdx
leaq 0x9387(%rip), %rsi      # 0x12704
leaq -0xb8(%rbp), %rdi
callq 0x7600
jmp 0x938b
callq 0x5030
movq -0x108(%rbp), %rdi
movl (%rax), %edx
leaq -0xb8(%rbp), %rsi
callq 0x76b0
jmp 0x93a7
movq -0x108(%rbp), %rdi
movb $0x0, -0xcd(%rbp)
leaq 0xe244(%rip), %rsi      # 0x17600
leaq -0x1c43(%rip), %rdx     # 0x7780
callq 0x5680
jmp 0x953d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x93ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5230
leaq -0xb9(%rbp), %rdi
callq 0x53f0
testb $0x1, -0xcd(%rbp)
jne 0x9416
jmp 0x9422
movq -0x108(%rbp), %rdi
callq 0x52a0
jmp 0x9531
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5510
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x9528
movb $0x1, -0xf2(%rbp)
movl $0x10, %edi
callq 0x51b0
movq %rax, -0x118(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x56c0
movq -0x110(%rbp), %rdx
leaq 0x9292(%rip), %rsi      # 0x12716
leaq -0xf0(%rbp), %rdi
callq 0x7600
jmp 0x9492
callq 0x5030
movq -0x118(%rbp), %rdi
movl (%rax), %edx
leaq -0xf0(%rbp), %rsi
callq 0x76b0
jmp 0x94ae
movq -0x118(%rbp), %rdi
movb $0x0, -0xf2(%rbp)
leaq 0xe13d(%rip), %rsi      # 0x17600
leaq -0x1d4a(%rip), %rdx     # 0x7780
callq 0x5680
jmp 0x953d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x9503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x5230
leaq -0xf1(%rbp), %rdi
callq 0x53f0
testb $0x1, -0xf2(%rbp)
jne 0x951a
jmp 0x9526
movq -0x118(%rbp), %rdi
callq 0x52a0
jmp 0x9531
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x56b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0xdf85(%rip), %rdi      # 0x17fb0
leaq 0x889a(%rip), %rsi      # 0x128cc
callq 0x5380
movq %rax, %rdi
leaq 0x88b1(%rip), %rsi      # 0x128f2
callq 0x5380
movq %rax, %rdi
leaq 0x88d7(%rip), %rsi      # 0x12927
callq 0x5380
movq %rax, %rdi
leaq 0x8901(%rip), %rsi      # 0x12960
callq 0x5380
movq %rax, %rdi
leaq 0x8935(%rip), %rsi      # 0x129a3
callq 0x5380
movq %rax, %rdi
leaq 0x8953(%rip), %rsi      # 0x129d0
callq 0x5380
movq %rax, %rdi
leaq 0x896c(%rip), %rsi      # 0x129f8
callq 0x5380
movq %rax, %rdi
leaq 0x89a1(%rip), %rsi      # 0x12a3c
callq 0x5380
movq %rax, %rdi
leaq 0x89d1(%rip), %rsi      # 0x12a7b
callq 0x5380
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: merelin[P]mediasmartserverd/src/led_acerh340.h
// Function: LedAcerH340::SetBrightness(int)
virtual void SetBrightness( int val ) {
		static const unsigned char LED_BRIGHTNESS[] = {
			0x00, 0xbe, 0xc3, 0xcb, 0xd3, 0xdb, 0xe3, 0xeb, 0xf3, 0xff
		};
		val = std::max( 0, std::min<int>( val, sizeof(LED_BRIGHTNESS) / sizeof(LED_BRIGHTNESS[0]) - 1 ) );
		
		outb( HWM_PWM3_DUTY_CYCLE, io_sch5127_regs_ + REG_HWM_INDEX );
		outb( LED_BRIGHTNESS[val], io_sch5127_regs_ + REG_HWM_DATA  );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x9, -0x14(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xdae0
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0xdaa0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0xc(%rbp)
movl 0xc(%rax), %eax
addl $0x70, %eax
movl $0x32, %edi
movzwl %ax, %esi
callq 0xb0b0
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x6b1b(%rip), %rcx      # 0x12fd7
movb (%rcx,%rdx), %cl
movl 0xc(%rax), %eax
addl $0x71, %eax
movzbl %cl, %edi
movzwl %ax, %esi
callq 0xb0b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %eax
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc52e
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
xorb $-0x1, %al
movzbl %al, %edx
andl $0x1, %edx
movl $0x14, %esi
callq 0xd880
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc552
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
xorb $-0x1, %al
movzbl %al, %edx
andl $0x1, %edx
movl $0x18, %esi
callq 0xd880
movl $0x4, %eax
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc57f
movl -0x18(%rbp), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc595
movl -0x18(%rbp), %eax
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xc5b5
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl 0x8(%rdi), %edx
addl $0x18, %edx
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xd8e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xc6e0
testb $0x1, %al
jne 0xc693
movb $0x0, -0x1(%rbp)
jmp 0xc6b3
movq -0x18(%rbp), %rdi
callq 0xc9e0
testb $0x1, %al
jne 0xc6a6
movb $0x0, -0x1(%rbp)
jmp 0xc6b3
movq -0x18(%rbp), %rdi
callq 0xcfd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x5f22(%rip), %rcx      # 0x12f10
movq %rcx, -0x20(%rbp)
movq 0x5f1f(%rip), %rcx      # 0x12f18
movq %rcx, -0x18(%rbp)
movq $0x4, -0x28(%rbp)
movl $0x65, -0x2c(%rbp)
movl $0x68, -0x30(%rbp)
movl $0x4, -0x34(%rbp)
movl 0xc(%rax), %eax
addl $0x65, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5620
cmpl $0x0, %eax
je 0xd0f8
movb $0x1, -0x6d(%rbp)
movl $0x10, %edi
callq 0x51b0
movq %rax, -0x90(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x56c0
movq -0x88(%rbp), %rdx
leaq 0x5b77(%rip), %rsi      # 0x12be6
leaq -0x58(%rbp), %rdi
callq 0x7600
jmp 0xd07a
callq 0x5030
movq -0x90(%rbp), %rdi
movl (%rax), %edx
leaq -0x58(%rbp), %rsi
callq 0x76b0
jmp 0xd093
movq -0x90(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0xa55b(%rip), %rsi      # 0x17600
leaq -0x592c(%rip), %rdx     # 0x7780
callq 0x5680
jmp 0xd15a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd0d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5230
leaq -0x59(%rbp), %rdi
callq 0x53f0
testb $0x1, -0x6d(%rbp)
jne 0xd0ea
jmp 0xd0f6
movq -0x90(%rbp), %rdi
callq 0x52a0
jmp 0xd151
movq $0x0, -0x78(%rbp)
cmpq $0x4, -0x78(%rbp)
jae 0xd12e
movq -0x80(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x78(%rbp), %rcx
addl -0x20(%rbp,%rcx,4), %eax
xorl %edi, %edi
movzwl %ax, %esi
callq 0xb0b0
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0xd100
movq -0x80(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x65, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x5620
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x56b0
nopw (%rax,%rax)
// File: merelin[P]mediasmartserverd/src/led_acerh340.h
// Function: LedAcerH340::enableLeds_()
void enableLeds_( ) {
		// work out which bits we need
		int bits1 = 0, bits2 = 0;
		setBit32_( OUT_USB_DEVICE,	bits1, bits2 );
		setBit32_( OUT_USB_LED,		bits1, bits2 );
		setBit32_( OUT_POWER,		bits1, bits2 );
		setBit32_( OUT_SYSTEM_BLUE,	bits1, bits2 );
		setBit32_( OUT_SYSTEM_RED,	bits1, bits2 );
		
		setGpioSelInput_( bits1, bits2 );
		
		//TODO: SCH5127 bits
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x6, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x1b, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x19, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x14, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x18, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xd3c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0x8(%rdi), %edx
movl -0xc(%rbp), %r8d
movl $0x38, %eax
movl $0xc, %ecx
cmpl $0x20, %r8d
cmovll %ecx, %eax
addl %eax, %edx
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xd8e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::doBits_(unsigned int, unsigned int, bool)
void doBits_( unsigned int bits, unsigned int port, bool state ) {
		const unsigned int val = inl( port );
		const unsigned int new_val = ( state )
			?	val | bits
			:	val & ~bits
		;
		if ( val != new_val ) outl( new_val, port );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0x10(%rbp), %eax
movzwl %ax, %edi
callq 0xb090
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0xd918
movl -0x18(%rbp), %eax
orl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xd926
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xd942
movl -0x1c(%rbp), %edi
movl -0x10(%rbp), %eax
movzwl %ax, %esi
callq 0xb070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xd985
jmp 0xd9a4
leaq 0x52ae(%rip), %rdi      # 0x12c3a
leaq 0x52b0(%rip), %rsi      # 0x12c43
movl $0x11a, %edx            # imm = 0x11A
leaq 0x52c3(%rip), %rcx      # 0x12c62
callq 0x5250
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0xc(%rdi), %edx
addl $0x4b, %edx
addl -0x14(%rbp), %edx
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xd8e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x10877
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x108d0
movl %eax, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10930
movl %eax, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1082a
movl $0x7, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x1c, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movl $0x1b, %edi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd370
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xd3c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: testPush(char const*, char const*, char const*, net::IOBuffer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPush(const char *module, const char *msg, const char *data, Buffer &b, std::string &s, bool const expect = true){
	bool const result = b.push(data);

	if (expect)
		s += data;

	PRINTF_TEST(msg,	result == expect			);
	PRINTF_TEST("value",	s.compare(0, s.size(), b.data()) == 0	);

}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1650
andb $0x1, %al
movb %al, 0x1e(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x1251
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x1090
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movb 0x1e(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
leaq 0xdaa(%rip), %rcx       # 0x201f
leaq 0xda0(%rip), %rax       # 0x201c
cmpl %r8d, %edi
cmoveq %rax, %rcx
leaq 0xd7a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1080
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0xd3f(%rip), %rcx       # 0x201f
leaq 0xd35(%rip), %rax       # 0x201c
cmpl $0x0, %edx
cmoveq %rax, %rcx
leaq 0xd0f(%rip), %rdi       # 0x2004
leaq 0xd28(%rip), %rdx       # 0x2024
movb $0x0, %al
callq 0x1030
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movb %r9b, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x16f0
andb $0x1, %al
movb %al, 0x2e(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x1365
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movb 0x2e(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
leaq 0xc96(%rip), %rcx       # 0x201f
leaq 0xc8c(%rip), %rax       # 0x201c
cmpl %r8d, %edi
cmoveq %rax, %rcx
leaq 0xc66(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq 0x30(%rsp), %rdi
callq 0x10e0
testb $0x1, %al
jne 0x13b5
jmp 0x13fe
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1780
movq 0x20(%rsp), %rsi
movq %rax, %rdx
leaq 0xc47(%rip), %rcx       # 0x201f
leaq 0xc3d(%rip), %rax       # 0x201c
cmpq $0x0, %rdx
cmoveq %rax, %rcx
leaq 0xc16(%rip), %rdi       # 0x2004
leaq 0xc35(%rip), %rdx       # 0x202a
movb $0x0, %al
callq 0x1030
jmp 0x1472
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1080
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movq 0x18(%rsp), %rsi
movl %eax, %edx
leaq 0xbd0(%rip), %rcx       # 0x201f
leaq 0xbc6(%rip), %rax       # 0x201c
cmpl $0x0, %edx
cmoveq %rax, %rcx
leaq 0xba0(%rip), %rdi       # 0x2004
leaq 0xbb9(%rip), %rdx       # 0x2024
movb $0x0, %al
callq 0x1030
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17b0
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10d0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x70(%rsp), %rdi
leaq 0xb77(%rip), %rsi       # 0x2034
leaq 0xb75(%rip), %rdx       # 0x2039
movl $0x1, %r9d
callq 0x1200
jmp 0x14d1
movq 0x70(%rsp), %rdi
leaq 0xb60(%rip), %rsi       # 0x203d
leaq 0xb37(%rip), %rdx       # 0x201b
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %r9d, %r9d
callq 0x1200
jmp 0x14f8
movq 0x70(%rsp), %rdi
leaq 0xb30(%rip), %rsi       # 0x2034
leaq 0xb3c(%rip), %rdx       # 0x2047
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %r9d
callq 0x1200
jmp 0x1522
movq 0x70(%rsp), %rdi
leaq 0xb06(%rip), %rsi       # 0x2034
leaq 0xb16(%rip), %rdx       # 0x204b
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %r9d
callq 0x1200
jmp 0x154c
movq 0x70(%rsp), %rdi
leaq 0xaf7(%rip), %rsi       # 0x204f
movl $0x3, %edx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %r9d
callq 0x1310
jmp 0x1574
movq 0x70(%rsp), %rdi
leaq 0xad3(%rip), %rsi       # 0x2053
xorl %r9d, %r9d
movl %r9d, %edx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x1310
jmp 0x1597
movq 0x70(%rsp), %rdi
leaq 0xaac(%rip), %rsi       # 0x204f
movl $0x3, %edx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %r9d
callq 0x1310
jmp 0x15bf
movq 0x70(%rsp), %rdi
leaq 0xa84(%rip), %rsi       # 0x204f
movl $0x3, %edx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %r9d
callq 0x1310
jmp 0x15e7
leaq 0x28(%rsp), %rdi
callq 0x1070
leaq 0x48(%rsp), %rdi
callq 0x17d0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1070
leaq 0x48(%rsp), %rdi
callq 0x17d0
movq 0x20(%rsp), %rdi
callq 0x10f0
nopl (%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x144d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x143a
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1412
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %ecx
subl -0x4(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x14c3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x14b0
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x148e
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1527
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x150b
movl $0x20, %edi
callq 0x1170
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1170
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14e3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1597
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x158a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x158c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x154d
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x15ba
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x159d
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x32d0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x32f0
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3310
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3330
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x3a40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3940
jmp 0x2ae9
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a40
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b77
movq -0x38(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3a70
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x35d0
jmp 0x2b35
jmp 0x2b37
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2af1
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x37c0
movq -0x48(%rbp), %rdi
callq 0x3820
movq -0x30(%rbp), %rdi
callq 0x3880
movq -0x50(%rbp), %rdi
callq 0x38e0
jmp 0x2b7d
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x3a40
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2ca2
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x3a70
movq %rax, %rdi
callq 0x3a90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2c7e
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x3a70
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3ab0
movl (%rax), %esi
movq 0x1d374(%rip), %rdi     # 0x1ffd0
callq 0x22f0
movq %rax, %rdi
leaq 0x12a3c(%rip), %rsi     # 0x156a7
callq 0x2190
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2c09
movq 0x1d34b(%rip), %rdi     # 0x1ffd0
leaq 0x129ed(%rip), %rsi     # 0x15679
callq 0x2190
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2bdc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x12385(%rip), %rsi     # 0x15058
callq 0x21f0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
callq 0x3a40
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x2da8
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x3a70
movq %rax, %rdi
callq 0x3a90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d85
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x3a70
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x3ab0
movq -0x48(%rbp), %rdi
movl (%rax), %edx
leaq 0x122eb(%rip), %rsi     # 0x1505b
movb $0x0, %al
callq 0x2260
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2d11
movq -0x18(%rbp), %rdi
leaq 0x128e9(%rip), %rsi     # 0x15679
movb $0x0, %al
callq 0x2260
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ce4
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x2f61
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3ad0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0xc(%rbp), %esi
callq 0x3c80
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0x2f51
movl -0xc(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d40
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d80
movq %rax, %rcx
movl -0x58(%rbp), %eax
cmpl (%rcx), %eax
jbe 0x2f41
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
callq 0x3da0
cmpq $0x0, %rax
je 0x2eed
leaq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d80
movl (%rax), %esi
movq 0x1d152(%rip), %rdi     # 0x1ffd0
callq 0x2250
movq %rax, %rdi
leaq 0x1281a(%rip), %rsi     # 0x156a7
callq 0x2190
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x12800(%rip), %rsi     # 0x156a7
callq 0x2190
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3dc0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3e00
movq -0x60(%rbp), %rdi
movss (%rax), %xmm0
callq 0x2130
movq %rax, %rdi
movq 0x1d0da(%rip), %rsi     # 0x1ffc0
callq 0x21d0
jmp 0x2f3f
leaq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d40
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3d80
movl (%rax), %esi
movq 0x1d0bf(%rip), %rdi     # 0x1ffd0
callq 0x2250
movq %rax, %rdi
leaq 0x12787(%rip), %rsi     # 0x156a7
callq 0x2190
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2250
movq %rax, %rdi
movq 0x1d086(%rip), %rsi     # 0x1ffc0
callq 0x21d0
jmp 0x2f41
jmp 0x2f43
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2df5
jmp 0x2f53
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2dcb
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x22e0
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x3350
movl %eax, -0x220(%rbp)
jmp 0x31ec
movl -0x220(%rbp), %edx
movq -0x228(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x2030
jmp 0x3207
movq -0x230(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x2240
jmp 0x3221
movq -0x230(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3400
movq %rax, %rsi
movq -0x230(%rbp), %rax
movl (%rax), %eax
shll $0x2, %eax
movl %eax, %edx
leaq -0x210(%rbp), %rdi
callq 0x2240
jmp 0x3254
movq -0x230(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34b0
movq %rax, %rsi
movq -0x230(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
leaq -0x210(%rbp), %rdi
callq 0x2240
jmp 0x3288
leaq -0x210(%rbp), %rdi
callq 0x2290
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2290
movq -0x218(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)