LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kusumi[P]procstat/container.cc
// Function: Container::_alloc_window(int, int, int, int, int)
void Container::_alloc_window(int seq, int ylen, int xlen, int ypos, int xpos)
{
	try {
		Window *p = _v.at(seq);
		p->resize(ylen, xlen, ypos, xpos);
		p->signal();
	} catch (const std::out_of_range &e) {
		Window *p = new Window(ylen, xlen, ypos, xpos);
		_v.push_back(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x7490
movq %rax, -0x50(%rbp)
jmp 0x68c4
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0xa1a0
jmp 0x68e7
movq -0x28(%rbp), %rdi
callq 0xa810
jmp 0x68f2
jmp 0x6961
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6998
movq -0x30(%rbp), %rdi
callq 0x4170
movq %rax, -0x40(%rbp)
movl $0x80, %edi
callq 0x4410
movq %rax, -0x60(%rbp)
jmp 0x692d
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x9fa0
jmp 0x6945
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x74d0
jmp 0x695c
callq 0x4720
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x698f
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x80, %esi
callq 0x4430
callq 0x4720
jmp 0x6996
jmp 0x6998
movq -0x30(%rbp), %rdi
callq 0x47b0
movq %rax, %rdi
callq 0x56a0
nopl (%rax)
// File: kusumi[P]procstat/container.cc
// Function: Container::thread_create()
int Container::thread_create(void)
{
	int ret = _thread.create(watch_thread_handler, 0);
	if (ret) {
		log("create thread failed %d", ret);
		return ret;
	}

	for (size_t i = 0; i < _v.size(); i++) {
		ret = _v[i]->create();
		if (ret) {
			log("window=%p create thread failed %d",
				static_cast<void*>(_v[i]), ret);
			return ret;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1097d(%rip), %rdi     # 0x17568
leaq 0x8e(%rip), %rsi        # 0x6c80
xorl %eax, %eax
movl %eax, %edx
callq 0x7540
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6c0c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6c6e
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6f90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c67
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6fb0
movq (%rax), %rdi
callq 0xa8a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6c57
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6c6e
jmp 0x6c59
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6c14
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kusumi[P]procstat/container.cc
// Function: watch_thread_handler(void*)
static void *watch_thread_handler(void *arg)
{
	log("thread=%lu", get_thread_id());
	while (!interrupted) {
		watch_res r;
		if (read_watch(r) > 0) {
			for (watch_res::iterator it = r.begin(); it != r.end();
				it++) {
				Window *p = _map[it->first];
				switch (it->second) {
				case WATCH_MODIFY:
					p->update_buffer();
					break;
				}
			}
			flash_terminal();
		}
		_mutex.timedwait(1, 0);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x107e6(%rip), %rax     # 0x1747c
movl (%rax), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6ca9
jmp 0x6da1
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7ad0
movq -0x78(%rbp), %rdi
callq 0xd450
movl %eax, -0x6c(%rbp)
jmp 0x6cc4
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
jle 0x6d7c
leaq -0x38(%rbp), %rdi
callq 0x7af0
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7b50
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7b20
testb $0x1, %al
jne 0x6cfd
jmp 0x6d73
leaq -0x50(%rbp), %rdi
callq 0x7c60
movq %rax, %rsi
leaq 0x10828(%rip), %rdi     # 0x17538
callq 0x7b80
movq %rax, -0x80(%rbp)
jmp 0x6d1b
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7c60
movl 0x4(%rax), %eax
subl $0x1, %eax
je 0x6d50
jmp 0x6d5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7cd0
jmp 0x6dac
movq -0x60(%rbp), %rdi
callq 0xa3f0
jmp 0x6d5b
jmp 0x6d5d
jmp 0x6d5f
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x7c90
movq %rax, -0x68(%rbp)
jmp 0x6cdd
callq 0xceb0
jmp 0x6d7a
jmp 0x6d7c
leaq 0x1075d(%rip), %rdi     # 0x174e0
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xc970
jmp 0x6d93
leaq -0x38(%rbp), %rdi
callq 0x7cd0
jmp 0x6c8f
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x47b0
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/container.cc
// Function: Container::thread_join()
void Container::thread_join(void)
{
	int ret;
	for (size_t i = 0; i < _v.size(); i++)
		_v[i]->signal();
	for (size_t i = 0; i < _v.size(); i++) {
		ret = _v[i]->join();
		if (ret)
			log("window=%p join thread failed %d",
				static_cast<void*>(_v[i]), ret);
	}

	_mutex.signal();
	ret = _thread.join();
	if (ret)
		log("join thread failed %d", ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6f90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x6e1c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6fb0
movq (%rax), %rdi
callq 0xa810
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ddc
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6f90
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x6e71
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6fb0
movq (%rax), %rdi
callq 0x7570
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6e61
jmp 0x6e61
jmp 0x6e63
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e24
leaq 0x10668(%rip), %rdi     # 0x174e0
callq 0x7590
leaq 0x106e4(%rip), %rdi     # 0x17568
callq 0x75b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6e94
jmp 0x6e94
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kusumi[P]procstat/window.cc
// Function: Window::Window(int, int, int, int)
Window::Window(int ylen, int xlen, int ypos, int xpos):
	_frame(0),
	_panel(0),
	_buffer(0),
	_offset(0)
{
	_frame = new Frame(ylen, xlen, ypos, xpos);
	_panel = new Panel(ylen - 2, xlen - 2, ypos + 1, xpos + 1);
	_frame->refresh();
	_panel->refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x6ea0
movq -0x38(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movl $0x0, 0x78(%rax)
movl $0x48, %edi
callq 0x4410
movq %rax, -0x30(%rbp)
jmp 0xa000
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
callq 0xaf40
jmp 0xa018
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x20, %edi
callq 0x4410
movq %rax, -0x48(%rbp)
jmp 0xa034
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $-0x2, %esi
movl -0x10(%rbp), %edx
addl $-0x2, %edx
movl -0x14(%rbp), %ecx
incl %ecx
movl -0x18(%rbp), %r8d
incl %r8d
callq 0xad50
jmp 0xa057
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq 0x60(%rax), %rdi
callq 0xa9d0
jmp 0xa06e
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0xa9d0
jmp 0xa07d
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa0c7
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x4430
jmp 0xa0c7
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x4430
movq -0x38(%rbp), %rdi
callq 0x6ee0
movq -0x20(%rbp), %rdi
callq 0x47b0
nopl (%rax)
// File: kusumi[P]procstat/window.cc
// Function: Window::~Window()
Window::~Window(void)
{
	delete _buffer;
	delete _frame;
	delete _panel;
	log("window=%p", static_cast<void*>(this));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xa119
movq -0x10(%rbp), %rdi
callq 0xa9f0
movq -0x10(%rbp), %rdi
movl $0x2a8, %esi            # imm = 0x2A8
callq 0x4430
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xa135
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xa151
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x6ee0
addq $0x30, %rsp
popq %rbp
retq
// File: kusumi[P]procstat/window.cc
// Function: Window::resize(int, int, int, int)
void Window::resize(int ylen, int xlen, int ypos, int xpos)
{
	_mutex.lock();
	_frame->resize(ylen, xlen, ypos, xpos);
	_panel->resize(ylen - 2, xlen - 2, ypos + 1, xpos + 1);
	_offset = 0;
	_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xaa50
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0xc(%rbp), %esi
subl $0x2, %esi
movl -0x10(%rbp), %edx
subl $0x2, %edx
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl -0x18(%rbp), %r8d
addl $0x1, %r8d
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x20(%rbp), %rdi
movl $0x0, 0x78(%rdi)
callq 0xaa70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kusumi[P]procstat/window.cc
// Function: Window::attach_buffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Window::attach_buffer(std::string f)
{
	_mutex.lock();
	if (_buffer) {
		_mutex.unlock();
		return;
	}
	_frame->set_title(f);
	_panel->set_title(f);
	_mutex.unlock();
	_buffer = new Buffer(f);
	log("window=%p path=%s", static_cast<void*>(this),
		_buffer->get_path().c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xaa50
movq -0x90(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0xa269
movq -0x90(%rbp), %rdi
callq 0xaa70
jmp 0xa369
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x41a0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xa2ab
leaq -0x30(%rbp), %rdi
callq 0x4878
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rsi
movq 0x68(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x41a0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xa2f6
leaq -0x60(%rbp), %rdi
callq 0x4878
movq -0x90(%rbp), %rdi
callq 0xaa70
movl $0x2a8, %edi            # imm = 0x2A8
callq 0x4410
movq -0x98(%rbp), %rsi
movq %rax, -0xc0(%rbp)
movb $0x1, -0x81(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x41a0
jmp 0xa335
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb270
jmp 0xa347
movq -0x90(%rbp), %rax
movq -0xc0(%rbp), %rcx
movb $0x0, -0x81(%rbp)
movq %rcx, 0x70(%rax)
leaq -0x80(%rbp), %rdi
callq 0x4878
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4878
jmp 0xa3e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4878
jmp 0xa3e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xa3c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4878
testb $0x1, -0x81(%rbp)
jne 0xa3ce
jmp 0xa3df
movq -0xc0(%rbp), %rdi
movl $0x2a8, %esi            # imm = 0x2A8
callq 0x4430
jmp 0xa3e1
movq -0x38(%rbp), %rdi
callq 0x47b0
nopw (%rax,%rax)
// File: kusumi[P]procstat/window.cc
// Function: Window::focus(bool)
void Window::focus(bool t)
{
	_mutex.lock();
	_frame->set_focus(t);
	_panel->set_focus(t);
	_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xaa50
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movb -0x9(%rbp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movb -0x9(%rbp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0xaa70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kusumi[P]procstat/window.cc
// Function: Window::goto_current(int)
void Window::goto_current(int d)
{
	_mutex.lock();
	int x = _offset + d;
	if (x < 0)
		x = 0;
	if (x > _buffer->get_max_line())
		x = _buffer->get_max_line();
	_offset = x;
	_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xaa50
movq -0x18(%rbp), %rax
movl 0x78(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xa516
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x70(%rax), %rdi
callq 0xb490
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jle 0xa542
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xb490
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, 0x78(%rdi)
callq 0xaa70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kusumi[P]procstat/window.cc
// Function: thread_handler(void*)
static void *thread_handler(void *arg)
{
	Window *p = reinterpret_cast<Window*>(arg);
	long t = 0;
	if (usedelay) {
		long va = reinterpret_cast<long>(p);
		if (sinterval)
			t = va % 1000;
		else
			t = va % (ninterval / 1000 / 1000);
	}
	log("window=%p thread=%lu delay=%ld", static_cast<void*>(p),
		get_thread_id(), t);
	if (t) {
		p->repaint();
		p->timedwait(0, t * 1000 * 1000);
	}
	while (!interrupted) {
		p->repaint();
		p->timedwait(sinterval, ninterval);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xcbb8(%rip), %rax      # 0x174ab
testb $0x1, (%rax)
je 0xa959
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xcb91(%rip), %rax      # 0x17498
cmpq $0x0, (%rax)
je 0xa921
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
jmp 0xa957
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xcb70(%rip), %rax      # 0x174a0
movq (%rax), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
jmp 0xa959
cmpq $0x0, -0x18(%rbp)
je 0xa985
movq -0x10(%rbp), %rdi
callq 0xa560
movq -0x10(%rbp), %rdi
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
imulq $0x3e8, %rax, %rdx      # imm = 0x3E8
xorl %eax, %eax
movl %eax, %esi
callq 0xa850
jmp 0xa987
leaq 0xcaee(%rip), %rax      # 0x1747c
movl (%rax), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa99e
jmp 0xa9c6
movq -0x10(%rbp), %rdi
callq 0xa560
movq -0x10(%rbp), %rdi
leaq 0xcae6(%rip), %rax      # 0x17498
movq (%rax), %rsi
leaq 0xcae4(%rip), %rax      # 0x174a0
movq (%rax), %rdx
callq 0xa850
jmp 0xa987
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kusumi[P]procstat/panel.cc
// Function: Panel::Panel(int, int, int, int)
Panel::Panel(int ylen, int xlen, int ypos, int xpos):
	_scr(0),
	_ylen(ylen),
	_xlen(xlen),
	_ypos(ypos),
	_xpos(xpos)
{
	_scr = alloc_screen(_ylen, _xlen, _ypos, _xpos);
	if (!_scr)
		throw std::bad_alloc();
	bkgd_screen(_scr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xbf28(%rip), %rcx      # 0x16ca0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x10(%rax), %edi
movl 0x14(%rax), %esi
movl 0x18(%rax), %edx
movl 0x1c(%rax), %ecx
callq 0xcec0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0xadef
movl $0x8, %edi
callq 0x4200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0xb100
movq -0x28(%rbp), %rdi
movq 0xc1e5(%rip), %rsi      # 0x16fc8
movq 0xc1b6(%rip), %rdx      # 0x16fa0
callq 0x4780
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd250
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/panel.cc
// Function: Panel::_resize(int, int, int, int)
void Panel::_resize(int ylen, int xlen, int ypos, int xpos)
{
	_ylen = ylen;
	_xlen = xlen;
	_ypos = ypos;
	_xpos = xpos;
	resize_screen(_scr, _ylen, _xlen);
	move_screen(_scr, _ypos, _xpos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
movl 0x14(%rax), %edx
callq 0xd120
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x18(%rax), %esi
movl 0x1c(%rax), %edx
callq 0xd160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/buffer.cc
// Function: Buffer::update()
void Buffer::update(void)
{
	if (is_dead())
		return;
	block_till_ready();
	size_t tmp = _ifs.tellg();
	_ifs.seekg(0);
	_maxline = std::count(std::istreambuf_iterator<char>(_ifs),
		std::istreambuf_iterator<char>(), '\n') - 1;
	_ifs.seekg(tmp);
	signal_blocked();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xb560
testb $0x1, %al
jne 0xb3b2
jmp 0xb3b7
jmp 0xb484
movq -0x70(%rbp), %rdi
callq 0xb4d0
movq -0x70(%rbp), %rdi
addq $0x70, %rdi
callq 0x47a0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb920
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x10(%rbp)
addq $0x70, %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb940
movq -0x80(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x45c0
movq -0x70(%rbp), %rsi
addq $0x70, %rsi
leaq -0x40(%rbp), %rdi
callq 0xb9f0
leaq -0x50(%rbp), %rdi
callq 0xba50
movb $0xa, -0x51(%rbp)
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x50(%rbp), %rdx
movl -0x48(%rbp), %ecx
leaq -0x51(%rbp), %r8
callq 0xb980
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq $0x1, %rcx
movl %ecx, 0x29c(%rax)
addq $0x70, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xb940
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x45c0
movq -0x70(%rbp), %rdi
callq 0xb520
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: kusumi[P]procstat/buffer.cc
// Function: Buffer::get_max_line()
int Buffer::get_max_line(void)
{
	block_till_ready();
	int ret = _maxline;
	signal_blocked();
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xb4d0
movq -0x18(%rbp), %rdi
movl 0x29c(%rdi), %eax
movl %eax, -0xc(%rbp)
callq 0xb520
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/buffer.cc
// Function: Buffer::block_till_ready()
void Buffer::block_till_ready(void)
{
	_mutex.lock();
	while (_busy)
		_mutex.wait();
	_busy = true;
	_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xaa50
movq -0x10(%rbp), %rax
testb $0x1, 0x2a0(%rax)
je 0xb501
movq -0x10(%rbp), %rdi
callq 0xbb80
jmp 0xb4e9
movq -0x10(%rbp), %rdi
movb $0x1, 0x2a0(%rdi)
callq 0xaa70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kusumi[P]procstat/buffer.cc
// Function: Buffer::signal_blocked()
void Buffer::signal_blocked(void)
{
	_mutex.lock();
	_busy = false;
	_mutex.signal();
	_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xaa50
movq -0x10(%rbp), %rdi
movb $0x0, 0x2a0(%rdi)
callq 0x7590
movq -0x10(%rbp), %rdi
callq 0xaa70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kusumi[P]procstat/buffer.cc
// Function: Buffer::is_dead()
bool Buffer::is_dead(void)
{
	block_till_ready();
	bool ret = !_ifs.is_open();
	signal_blocked();
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xb4d0
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x4700
movq -0x18(%rbp), %rdi
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0xb520
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: string_to_color(char const*)
short string_to_color(const char *arg)
{
	std::string s(arg);
	if (s == "black")
		return COLOR_BLACK;
	else if (s == "red")
		return COLOR_RED;
	else if (s == "green")
		return COLOR_GREEN;
	else if (s == "yellow")
		return COLOR_YELLOW;
	else if (s == "blue")
		return COLOR_BLUE;
	else if (s == "magenta")
		return COLOR_MAGENTA;
	else if (s == "cyan")
		return COLOR_CYAN;
	else if (s == "white")
		return COLOR_WHITE;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x47c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x6fd0
jmp 0xca64
leaq -0x31(%rbp), %rdi
callq 0x4490
leaq 0x2be0(%rip), %rsi      # 0xf654
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x59(%rbp)
jmp 0xca82
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xca8b
jmp 0xcad1
movw $0x0, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4490
jmp 0xcc46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4878
jmp 0xcc46
leaq 0x2b82(%rip), %rsi      # 0xf65a
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5a(%rbp)
jmp 0xcae6
movb -0x5a(%rbp), %al
testb $0x1, %al
jne 0xcaef
jmp 0xcb01
movw $0x1, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2b56(%rip), %rsi      # 0xf65e
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5b(%rbp)
jmp 0xcb16
movb -0x5b(%rbp), %al
testb $0x1, %al
jne 0xcb1f
jmp 0xcb31
movw $0x2, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2b2c(%rip), %rsi      # 0xf664
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5c(%rbp)
jmp 0xcb46
movb -0x5c(%rbp), %al
testb $0x1, %al
jne 0xcb4f
jmp 0xcb61
movw $0x3, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2b03(%rip), %rsi      # 0xf66b
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5d(%rbp)
jmp 0xcb76
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0xcb7f
jmp 0xcb91
movw $0x4, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2ad8(%rip), %rsi      # 0xf670
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5e(%rbp)
jmp 0xcba6
movb -0x5e(%rbp), %al
testb $0x1, %al
jne 0xcbaf
jmp 0xcbbe
movw $0x5, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2ab3(%rip), %rsi      # 0xf678
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x5f(%rbp)
jmp 0xcbd3
movb -0x5f(%rbp), %al
testb $0x1, %al
jne 0xcbdc
jmp 0xcbeb
movw $0x6, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
leaq 0x2a8b(%rip), %rsi      # 0xf67d
leaq -0x30(%rbp), %rdi
callq 0xd2a0
movb %al, -0x60(%rbp)
jmp 0xcc00
movb -0x60(%rbp), %al
testb $0x1, %al
jne 0xcc09
jmp 0xcc18
movw $0x7, -0x2(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xcc33
jmp 0xcc1a
jmp 0xcc1c
jmp 0xcc1e
jmp 0xcc20
jmp 0xcc22
jmp 0xcc24
jmp 0xcc26
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
movl $0x1, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4878
movw -0x2(%rbp), %ax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x47b0
nop
// File: kusumi[P]procstat/curses.cc
// Function: init_screen(short, short)
int init_screen(short fg, short bg)
{
	if (!initscr())
		return -1;
	if (keypad(stdscr, TRUE) == ERR)
		return -2;
	noecho();
	cbreak();
	curs_set(0);
	wtimeout(stdscr, 500);
	clear_terminal();

	if (has_colors() == TRUE) {
		if (start_color() == ERR)
			return -4;
		if (use_default_colors() == ERR)
			return -5;
		if (init_pair(1, fg, bg) == ERR)
			return -6;
		color_attr = COLOR_PAIR(1);
	}

	const char *env = getenv("TERM");
	if (env && !strcmp(env, "screen"))
		standout_attr = A_REVERSE;
	else
		standout_attr = A_STANDOUT;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
callq 0x4660
cmpq $0x0, %rax
jne 0xcc7d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcd7a
movq 0xa334(%rip), %rax      # 0x16fb8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x4160
cmpl $-0x1, %eax
jne 0xcca2
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xcd7a
callq 0x44e0
callq 0x4130
xorl %edi, %edi
callq 0x4360
movq 0xa2fe(%rip), %rax      # 0x16fb8
movq (%rax), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4500
callq 0xcd90
callq 0x46d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcd31
callq 0x40d0
cmpl $-0x1, %eax
jne 0xccf1
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xcd7a
callq 0x42b0
cmpl $-0x1, %eax
jne 0xcd04
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xcd7a
movw -0x6(%rbp), %ax
movl $0x1, %edi
movswl %ax, %esi
movswl -0x8(%rbp), %edx
callq 0x4080
cmpl $-0x1, %eax
jne 0xcd27
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0xcd7a
movl $0x100, 0xa867(%rip)    # imm = 0x100
leaq 0x294b(%rip), %rdi      # 0xf683
callq 0x4570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcd69
movq -0x10(%rbp), %rdi
leaq 0x2841(%rip), %rsi      # 0xf594
callq 0x4610
cmpl $0x0, %eax
jne 0xcd69
movl $0x40000, 0xa835(%rip)  # imm = 0x40000
jmp 0xcd73
movl $0x10000, 0xa829(%rip)  # imm = 0x10000
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: clear_terminal()
void clear_terminal(void)
{
	global_lock();
	wclear(stdscr);
	wrefresh(stdscr);
	global_unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xa7d5(%rip), %rdi      # 0x17570
callq 0x4650
movq 0xa211(%rip), %rax      # 0x16fb8
movq (%rax), %rdi
callq 0x4420
movq 0xa202(%rip), %rax      # 0x16fb8
movq (%rax), %rdi
callq 0x44c0
leaq 0xa7ab(%rip), %rdi      # 0x17570
callq 0x4330
popq %rbp
retq
nopl (%rax)
// File: kusumi[P]procstat/curses.cc
// Function: cleanup_screen()
int cleanup_screen(void)
{
	curs_set(1);
	if (endwin() == ERR)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
callq 0x4360
callq 0x4540
cmpl $-0x1, %eax
jne 0xcdf5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcdfc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: get_terminal_lines()
int get_terminal_lines(void)
{
	global_lock();
	int y = static_cast<int>(LINES);
	global_unlock();
	return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa731(%rip), %rdi      # 0x17570
callq 0x4650
movq 0xa11d(%rip), %rax      # 0x16f68
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq 0xa719(%rip), %rdi      # 0x17570
callq 0x4330
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: get_terminal_cols()
int get_terminal_cols(void)
{
	global_lock();
	int x = static_cast<int>(COLS);
	global_unlock();
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa6f1(%rip), %rdi      # 0x17570
callq 0x4650
movq 0xa0ed(%rip), %rax      # 0x16f78
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq 0xa6d9(%rip), %rdi      # 0x17570
callq 0x4330
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: alloc_screen(int, int, int, int)
Screen *alloc_screen(int ylen, int xlen, int ypos, int xpos)
{
	global_lock();
	Screen *scr = newwin(ylen, xlen, ypos, xpos);
	if (scr) {
		scrollok(scr, FALSE);
		idlok(scr, FALSE);
		keypad(scr, TRUE);
	}
	global_unlock();
	return scr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
leaq 0xa695(%rip), %rdi      # 0x17570
callq 0x4650
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x4450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcf20
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x44f0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x46f0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4160
leaq 0xa649(%rip), %rdi      # 0x17570
callq 0x4330
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: print_screen(_win_st*, int, int, bool, char const*, ...)
void print_screen(Screen *scr, int y, int x, bool standout, const char *fmt,
		...)
{
	int attr = standout ? standout_attr : A_NORMAL;
	global_lock();
	wattron(scr, attr);
	va_list ap;
	va_start(ap, fmt);
	mvwprintw(scr, y, x, fmt, ap);
	va_end(ap);
	wattroff(scr, attr);
	global_unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0xcfbb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %r8, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0xcfeb
movl 0xa5b9(%rip), %eax      # 0x1759c
movl %eax, -0xf4(%rbp)
jmp 0xcff5
xorl %eax, %eax
movl %eax, -0xf4(%rbp)
jmp 0xcff5
movl -0xf4(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0xa56b(%rip), %rdi      # 0x17570
movq %rdi, -0x100(%rbp)
callq 0x4650
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl %eax, -0x10c(%rbp)
movl %eax, %edx
movq %rdx, -0x108(%rbp)
callq 0x41f0
movl -0x10c(%rbp), %eax
leaq -0xf0(%rbp), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x28, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x40e0
movq -0x108(%rbp), %rdx
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x45d0
movq -0x100(%rbp), %rdi
callq 0x4330
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/curses.cc
// Function: box_screen(_win_st*)
void box_screen(Screen *scr)
{
	global_lock();
	wborder(scr, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE,
		ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER);
	global_unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa3bd(%rip), %rdi      # 0x17570
callq 0x4650
movq -0x8(%rbp), %rdi
movq 0x9dad(%rip), %rax      # 0x16f70
movl 0x1e0(%rax), %esi
movq 0x9da0(%rip), %rax      # 0x16f70
movl 0x1e0(%rax), %edx
movq 0x9d93(%rip), %rax      # 0x16f70
movl 0x1c4(%rax), %ecx
movq 0x9d86(%rip), %rax      # 0x16f70
movl 0x1c4(%rax), %r8d
movq 0x9d78(%rip), %rax      # 0x16f70
movl 0x1b0(%rax), %r9d
movq 0x9d6a(%rip), %rax      # 0x16f70
movl 0x1ac(%rax), %r11d
movq 0x9d5c(%rip), %rax      # 0x16f70
movl 0x1b4(%rax), %r10d
movq 0x9d4e(%rip), %rax      # 0x16f70
movl 0x1a8(%rax), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x4210
leaq 0xa32f(%rip), %rdi      # 0x17570
callq 0x4330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kusumi[P]procstat/curses.cc
// Function: bkgd_screen(_win_st*)
void bkgd_screen(Screen *scr)
{
	global_lock();
	if (color_attr != A_NORMAL)
		wbkgd(scr, color_attr | ' ');
	global_unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa30d(%rip), %rdi      # 0x17570
callq 0x4650
cmpl $0x0, 0xa329(%rip)      # 0x17598
je 0xd283
movq -0x8(%rbp), %rdi
movl 0xa31d(%rip), %esi      # 0x17598
orl $0x20, %esi
callq 0x4760
leaq 0xa2e6(%rip), %rdi      # 0x17570
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kusumi[P]procstat/watch.cc
// Function: init_watch(bool)
int init_watch(bool nonblock)
{
	fd = inotify_init();
	if (fd == -1)
		return -1;
	if (nonblock) {
		int ret = fcntl(fd, F_GETFL, 0);
		if (ret == -1 || fcntl(fd, F_SETFL, ret | O_NONBLOCK) == -1) {
			close(fd);
			return -1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x47e0
movl %eax, 0xa17d(%rip)      # 0x17468
cmpl $-0x1, 0xa176(%rip)     # 0x17468
jne 0xd2fd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd35d
testb $0x1, -0x5(%rbp)
je 0xd356
movl 0xa15f(%rip), %edi      # 0x17468
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x4260
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xd340
movl 0xa142(%rip), %edi      # 0x17468
movl -0xc(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x4260
cmpl $-0x1, %eax
jne 0xd354
movl 0xa122(%rip), %edi      # 0x17468
callq 0x4830
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd35d
jmp 0xd356
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/watch.cc
// Function: add_watch(char const*)
int add_watch(const char *path)
{
	int ret = inotify_add_watch(fd, path, IN_MODIFY);
	if (ret != -1)
		expand_buffer(1);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xa0c6(%rip), %edi      # 0x17468
movq -0x8(%rbp), %rsi
movl $0x2, %edx
callq 0x4230
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xd3c3
movl $0x1, %edi
callq 0xd3d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kusumi[P]procstat/watch.cc
// Function: delete_watch(int)
int delete_watch(int wd)
{
	int ret = inotify_rm_watch(fd, wd);
	if (ret != -1)
		expand_buffer(-1);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xa047(%rip), %edi      # 0x17468
movl -0x4(%rbp), %esi
callq 0x41e0
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0xd43c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd3d0
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kusumi[P]procstat/watch.cc
// Function: read_watch(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>&)
int read_watch(watch_res &r)
{
	char *p = &buf[0];
	int ret = read(fd, p, buf.size());
	if (ret == -1) {
		if (errno == EAGAIN)
			return 0;
		else
			return -1;
	}
	int i = 0;
	while (i < ret) {
		struct inotify_event *e =
			reinterpret_cast<struct inotify_event*>(p + i);
		if (e->mask & IN_MODIFY)
			r.insert(watch_res::value_type(e->wd, WATCH_MODIFY));
		i += sizeof(struct inotify_event) + e->len;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xa13d(%rip), %rdi      # 0x175a0
xorl %eax, %eax
movl %eax, %esi
callq 0xd5d0
movq %rax, -0x18(%rbp)
movl 0x9ff2(%rip), %eax      # 0x17468
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xa118(%rip), %rdi      # 0x175a0
callq 0xd5f0
movl -0x54(%rbp), %edi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x4630
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0xd4c7
callq 0x4050
cmpl $0xb, (%rax)
jne 0xd4bb
movl $0x0, -0x4(%rbp)
jmp 0xd547
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd547
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xd541
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xd528
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rsi
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0xd650
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd610
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
addq $0x10, %rcx
movslq -0x20(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x20(%rbp)
jmp 0xd4ce
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::fix_newlines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string fix_newlines(std::string leader, std::string input) {
    std::string::size_type n = 0;
    while(n != std::string::npos && n < input.size()) {
        n = input.find('\n', n);
        if(n != std::string::npos) {
            input = input.substr(0, n + 1) + leader + input.substr(n + 1);
            n += leader.size();
        }
    }
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x20(%rbp)
movb %al, -0xd1(%rbp)
je 0x8d2a
movq -0xd0(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
callq 0x62d0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x8d39
jmp 0x8e7d
movq -0xd0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa, %esi
callq 0x65b0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x8e78
movq -0xd0(%rbp), %rsi
movq -0x20(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x6420
movq -0xe8(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x12690
jmp 0x8d98
movq -0xd0(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0xb0(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6420
jmp 0x8dbb
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x125c0
jmp 0x8dd1
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x6280
leaq -0xb0(%rbp), %rdi
callq 0x6280
leaq -0x60(%rbp), %rdi
callq 0x6280
leaq -0x80(%rbp), %rdi
callq 0x6280
movq -0xc8(%rbp), %rdi
callq 0x62d0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8e78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8e6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8e64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6280
leaq -0x60(%rbp), %rdi
callq 0x6280
leaq -0x80(%rbp), %rdi
callq 0x6280
jmp 0x8ea0
jmp 0x8cee
movq -0xd0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x6250
movq -0xb8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::add_quotes_if_needed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline std::string &add_quotes_if_needed(std::string &str) {
    if((str.front() != '"' && str.front() != '\'') || str.front() != str.back()) {
        char quote = str.find('"') < str.find('\'') ? '\'' : '"';
        if(str.find(' ') != std::string::npos) {
            str.insert(0, 1, quote);
            str.append(1, quote);
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6110
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x902e
movq -0x8(%rbp), %rdi
callq 0x6110
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x9057
movq -0x8(%rbp), %rdi
callq 0x6110
movsbl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6300
movq %rax, %rcx
movl -0x10(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x90e5
movq -0x8(%rbp), %rdi
movl $0x22, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
movq -0x20(%rbp), %rcx
movq %rax, %rdx
movb $0x27, %al
movb $0x22, %sil
movb %sil, -0x12(%rbp)
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jb 0x909d
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x65b0
cmpq $-0x1, %rax
je 0x90e3
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movsbl -0x9(%rbp), %ecx
callq 0x6820
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movsbl -0x9(%rbp), %edx
callq 0x6450
jmp 0x90e5
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::vector<CLI::Option const*, std::allocator<CLI::Option const*>>) const
inline std::string
Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
    std::stringstream out;

    out << "\n" << group << ":\n";
    for(const Option *opt : opts) {
        out << make_option(opt, is_positional);
    }

    return out.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %r8, -0x230(%rbp)
movq %rdx, -0x228(%rbp)
movq %rdi, -0x220(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62e0
leaq -0x1a0(%rbp), %rdi
leaq 0x382cb(%rip), %rsi     # 0x41981
callq 0x63d0
movq %rax, -0x208(%rbp)
jmp 0x96c4
movq -0x228(%rbp), %rsi
movq -0x208(%rbp), %rdi
callq 0x6390
movq %rax, -0x238(%rbp)
jmp 0x96e0
movq -0x238(%rbp), %rdi
leaq 0x37b7e(%rip), %rsi     # 0x4126c
callq 0x63d0
jmp 0x96f5
movq -0x230(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x85c0
movq %rax, -0x1d0(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x85f0
movq %rax, -0x1d8(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x8620
testb $0x1, %al
jne 0x9745
jmp 0x97f6
leaq -0x1d0(%rbp), %rdi
callq 0x8660
movq -0x210(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1a0(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x1e0(%rbp), %rdx
movq (%rsi), %rax
movq 0x58(%rax), %rax
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
leaq -0x200(%rbp), %rdi
callq *%rax
jmp 0x9790
movq -0x240(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x6390
jmp 0x97a5
leaq -0x200(%rbp), %rdi
callq 0x6280
leaq -0x1d0(%rbp), %rdi
callq 0x90f0
jmp 0x9729
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x9827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x6280
jmp 0x9827
movq -0x220(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x63c0
jmp 0x980b
leaq -0x1b0(%rbp), %rdi
callq 0x6320
movq -0x218(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x1b0(%rbp), %rdi
callq 0x6320
movq -0x1b8(%rbp), %rdi
callq 0x6750
nop
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option* CLI::App::add_option<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (CLI::detail::enabler)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Option *add_option(std::string option_name,
                       T &variable, ///< The variable to set
                       std::string description = "") {

        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };

        Option *opt = add_option(option_name, fun, description, false);
        opt->type_name(detail::type_name<T>());
        return opt;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0xf0(%rbp)
movq %rcx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x37720
movq -0xf0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x61d0
jmp 0x9a5b
leaq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x19b90
jmp 0x9a6d
movq -0x100(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x61d0
jmp 0x9a82
movq -0xf8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
xorl %r8d, %r8d
callq 0x196d0
movq %rax, -0x108(%rbp)
jmp 0x9aac
leaq -0xc0(%rbp), %rdi
callq 0x6280
leaq -0xa0(%rbp), %rdi
callq 0x190f0
leaq -0x70(%rbp), %rdi
callq 0x6280
movq -0x108(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x118(%rbp)
callq 0x37850
movq %rax, -0x110(%rbp)
jmp 0x9af1
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6770
movq -0x110(%rbp), %rsi
movq -0x120(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
callq 0x8eb0
jmp 0x9b20
movq -0x118(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x377b0
jmp 0x9b35
leaq -0xe0(%rbp), %rdi
callq 0x6280
leaq -0xe1(%rbp), %rdi
callq 0x6460
movq -0x50(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x190f0
movq -0x128(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x9bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x9bbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x9bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x6280
leaq -0xa0(%rbp), %rdi
callq 0x190f0
leaq -0x70(%rbp), %rdi
callq 0x6280
jmp 0x9bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x9bf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x6280
leaq -0xe1(%rbp), %rdi
callq 0x6460
leaq -0x40(%rbp), %rdi
callq 0x190f0
movq -0x78(%rbp), %rdi
callq 0x6750
nop