LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3530
cmpq $0x0, 0x70(%rbx)
je 0x5822
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x32c0
movq 0x60(%rbx), %r15
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x5e56
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5869
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3380
movq 0x68(%rbx), %r15
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x5e56
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x58b0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3380
movq %rbx, %rdi
callq 0x32c0
movl $0x2a8, %edi            # imm = 0x2A8
callq 0x3360
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5e56
movq %rsp, %rsi
movq %r15, %rdi
callq 0x6130
movq %r15, 0x70(%rbx)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5906
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3380
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5932
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3380
jmp 0x5932
movq %rax, %rbx
movl $0x2a8, %esi            # imm = 0x2A8
movq %r15, %rdi
jmp 0x5965
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x596a
movq 0x30(%rsp), %rsi
jmp 0x5962
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x596a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3380
movq %rbx, %rdi
callq 0x3680
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3530
movq 0x60(%r14), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x18(%rax)
movq 0x68(%r14), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x18(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x3530
addl 0x78(%rbx), %r14d
xorl %ebp, %ebp
testl %r14d, %r14d
cmovgl %r14d, %ebp
movq 0x70(%rbx), %rdi
callq 0x62ac
cmpl %eax, %ebp
jle 0x5a1e
movq 0x70(%rbx), %rdi
callq 0x62ac
movl %eax, %ebp
movl %ebp, 0x78(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kusumi[P]procstat/window.cc
// Function: Window::repaint()
void Window::repaint(void)
{
	if (is_dead())
		return;

	int ret, pos, y = 0;
	bool standout;
	std::string s;

	_mutex.lock();
	int offset = _offset;
	int ylen = _panel->get_ylen();
	int xlen = _panel->get_xlen();
	_mutex.unlock();

	_buffer->block_till_ready();
	_panel->erase();
	while ((ret = _buffer->readline(pos, s, standout)) != -1) {
		_mutex.lock();
		if (y >= ylen || offset != _offset ||
			ylen != _panel->get_ylen() ||
			xlen != _panel->get_xlen()) {
			_mutex.unlock();
			break;
		}
		_mutex.unlock();
		if (pos < offset)
			continue;
		if (!foldline && (static_cast<int>(s.size()) > xlen))
			s = s.substr(0, xlen);
		_panel->print(y, 0, standout, s);
		if (!foldline) {
			y++;
		} else {
			size_t siz = s.size();
			y += (siz / xlen);
			if (siz % xlen)
				y++;
		}
	}
	_panel->refresh();
	_buffer->clear();
	_buffer->signal_blocked();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x5bdf
callq 0x6334
testb %al, %al
jne 0x5bdf
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x3530
movl 0x78(%rbx), %r12d
movq 0x68(%rbx), %rax
movl 0x10(%rax), %ebp
movslq 0x14(%rax), %r14
movq %rbx, %rdi
callq 0x32c0
movq 0x70(%rbx), %rdi
callq 0x62ce
movq 0x68(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x6e87
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movq 0x70(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movq %r13, %rdx
leaq 0x3(%rsp), %rcx
callq 0x6362
cmpl $-0x1, %eax
je 0x5ba4
movq %rbx, %rdi
callq 0x3530
cmpl %ebp, %r15d
jge 0x5b9c
cmpl 0x78(%rbx), %r12d
jne 0x5b9c
movq 0x68(%rbx), %rax
cmpl 0x10(%rax), %ebp
jne 0x5b9c
cmpl 0x14(%rax), %r14d
jne 0x5b9c
movq %rbx, %rdi
callq 0x32c0
cmpl %r12d, 0x4(%rsp)
jl 0x5aaa
leaq 0x68e0(%rip), %rax      # 0xc3f1
cmpb $0x0, (%rax)
jne 0x5b58
cmpl 0x10(%rsp), %r14d
jge 0x5b58
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x33a0
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
callq 0x34a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5b58
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3380
movq 0x68(%rbx), %rdi
movzbl 0x3(%rsp), %ecx
movl %r15d, %esi
xorl %edx, %edx
movq %r13, %r8
callq 0x5f98
leaq 0x687c(%rip), %rax      # 0xc3f1
cmpb $0x0, (%rax)
je 0x5b94
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq %r14
addl %eax, %r15d
cmpq $0x1, %rdx
sbbl $-0x1, %r15d
jmp 0x5aaa
incl %r15d
jmp 0x5aaa
movq %rbx, %rdi
callq 0x32c0
movq 0x68(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x6e5a
movq 0x70(%rbx), %rdi
callq 0x65a0
movq 0x70(%rbx), %rdi
callq 0x6312
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5bdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3380
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bf4
jmp 0x5bf4
jmp 0x5bf4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5c13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3380
movq %rbx, %rdi
callq 0x3680
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6763(%rip), %rax      # 0xc3f3
cmpb $0x1, (%rax)
jne 0x5ccf
leaq 0x6744(%rip), %rax      # 0xc3e0
cmpq $0x0, (%rax)
je 0x5cd4
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rbx, %r14
subq %rax, %r14
jmp 0x5d04
xorl %r14d, %r14d
jmp 0x5d04
leaq 0x670d(%rip), %rcx      # 0xc3e8
movabsq $0x431bde82d7b634db, %rax # imm = 0x431BDE82D7B634DB
imulq (%rcx)
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rcx
addq %rax, %rcx
movq %rbx, %rax
cqto
idivq %rcx
movq %rdx, %r14
testq %r14, %r14
je 0x5d35
movq %rbx, %rdi
callq 0x5a2e
imulq $0xf4240, %r14, %r14    # imm = 0xF4240
movq %rbx, %rdi
callq 0x3530
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x697a
movq %rbx, %rdi
callq 0x32c0
leaq 0x6688(%rip), %r12      # 0xc3c4
cmpl $0x0, (%r12)
jne 0x5d86
leaq 0x6696(%rip), %r13      # 0xc3e0
leaq 0x6697(%rip), %rbp      # 0xc3e8
movq %rbx, %rdi
callq 0x5a2e
movq (%r13), %r14
movq (%rbp), %r15
movq %rbx, %rdi
callq 0x3530
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x697a
movq %rbx, %rdi
callq 0x32c0
cmpl $0x0, (%r12)
je 0x5d51
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x5dbd(%rip), %rax      # 0xbcb0
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movl %ecx, 0x18(%rdi)
movl %r8d, 0x1c(%rdi)
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
callq 0x6cde
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5f2b
movq %rax, %rdi
popq %rbx
jmp 0x6f97
movl $0x8, %edi
callq 0x31b0
movq 0x6074(%rip), %rcx      # 0xbfb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6076(%rip), %rsi      # 0xbfc0
movq 0x604f(%rip), %rdx      # 0xbfa0
movq %rax, %rdi
callq 0x3640
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movl %ecx, 0x18(%rdi)
movl %r8d, 0x1c(%rdi)
movq 0x8(%rdi), %rdi
callq 0x6eb4
movq 0x8(%rbx), %rdi
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %edx
popq %rbx
jmp 0x6eef
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x6334
testb %al, %al
jne 0x62a1
movq %rbx, %rdi
callq 0x62ce
leaq 0x70(%rbx), %r14
movq %r14, %rdi
callq 0x3660
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x34d0
movq 0x70(%rbx), %rax
movq -0x18(%rax), %rax
movq 0x158(%rbx,%rax), %rdi
leaq 0xf(%rsp), %r8
movb $0xa, (%r8)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x660c
decl %eax
movl %eax, 0x29c(%rbx)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x34d0
movq %rbx, %rdi
callq 0x6312
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x62ce
movl 0x29c(%rbx), %ebp
movq %rbx, %rdi
callq 0x6312
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3530
cmpb $0x1, 0x2a0(%rbx)
jne 0x62fb
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3580
cmpb $0x0, 0x2a0(%rbx)
jne 0x62e7
movb $0x1, 0x2a0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kusumi[P]procstat/buffer.cc
// Function: Buffer::signal_blocked()
void Buffer::signal_blocked(void)
{
	_mutex.lock();
	_busy = false;
	_mutex.signal();
	_mutex.unlock();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3530
movb $0x0, 0x2a0(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x62ce
leaq 0xe8(%rbx), %rdi
callq 0x30c0
movl %eax, %ebp
xorb $0x1, %bpl
movq %rbx, %rdi
callq 0x6312
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5038
leaq 0x1be2(%rip), %rsi      # 0x8617
movq %rbx, %rdi
callq 0x3100
testl %eax, %eax
je 0x6ae3
leaq 0x1bd1(%rip), %rsi      # 0x861d
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6ae7
leaq 0x1bbc(%rip), %rsi      # 0x8621
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6aed
leaq 0x1bad(%rip), %rsi      # 0x8627
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6af3
leaq 0x1b9f(%rip), %rsi      # 0x862e
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6af9
leaq 0x1b8f(%rip), %rsi      # 0x8633
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6aff
leaq 0x1b82(%rip), %rsi      # 0x863b
leaq 0x10(%rsp), %rdi
callq 0x3100
testl %eax, %eax
je 0x6b05
leaq 0x1b72(%rip), %rsi      # 0x8640
leaq 0x10(%rsp), %rdi
callq 0x3100
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
orl $0x7, %ebx
jmp 0x6b09
xorl %ebx, %ebx
jmp 0x6b09
movw $0x1, %bx
jmp 0x6b09
movw $0x2, %bx
jmp 0x6b09
movw $0x3, %bx
jmp 0x6b09
movw $0x4, %bx
jmp 0x6b09
movw $0x5, %bx
jmp 0x6b09
movw $0x6, %bx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b24
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3380
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
callq 0x3540
testq %rax, %rax
je 0x6be6
movq 0x546f(%rip), %r14      # 0xbfb8
movq (%r14), %rdi
movl $0x1, %esi
callq 0x3150
cmpl $-0x1, %eax
je 0x6bed
callq 0x3410
callq 0x3110
xorl %edi, %edi
callq 0x32e0
movq (%r14), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x3430
callq 0x6c1b
callq 0x35b0
testb %al, %al
je 0x6bbb
callq 0x30b0
cmpl $-0x1, %eax
je 0x6bf4
callq 0x3250
cmpl $-0x1, %eax
je 0x6c0d
movswl %bp, %esi
movswl %bx, %edx
movl $0x1, %edi
callq 0x3080
cmpl $-0x1, %eax
je 0x6c14
movb $0x1, 0x5925(%rip)      # 0xc4e0
leaq 0x1a84(%rip), %rdi      # 0x8646
callq 0x3490
testq %rax, %rax
je 0x6bdf
leaq 0x193d(%rip), %rsi      # 0x8510
movq %rax, %rdi
callq 0x34f0
testl %eax, %eax
je 0x6bfb
movl $0x10000, %eax          # imm = 0x10000
jmp 0x6c00
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6c08
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x6c08
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x6c08
movl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x58de(%rip)      # 0xc4e4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x6c08
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x6c08
// File: /workspace/github_cpp_makefile_star2_O1/kusumi[P]procstat/curses.cc
// Function: clear_terminal()
void clear_terminal(void)
{
	global_lock();
	wclear(stdscr);
	wrefresh(stdscr);
	global_unlock();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5892(%rip), %rbx      # 0xc4b8
movq %rbx, %rdi
callq 0x3530
movq 0x5383(%rip), %r14      # 0xbfb8
movq (%r14), %rdi
callq 0x3370
movq (%r14), %rdi
callq 0x33e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
leaq 0x582d(%rip), %rbx      # 0xc4b8
movq %rbx, %rdi
callq 0x3530
movq 0x52ce(%rip), %rax      # 0xbf68
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x32c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
leaq 0x5801(%rip), %rbx      # 0xc4b8
movq %rbx, %rdi
callq 0x3530
movq 0x52ba(%rip), %rax      # 0xbf80
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x32c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x57c2(%rip), %rdi      # 0xc4b8
callq 0x3530
movl %r15d, %edi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x33b0
movq %rax, %rbx
testq %rax, %rax
je 0x6d33
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3420
movq %rbx, %rdi
xorl %esi, %esi
callq 0x35d0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3150
leaq 0x577e(%rip), %rdi      # 0xc4b8
callq 0x32c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r15
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r14
testb %al, %al
je 0x6dd3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
testl %ecx, %ecx
je 0x6de2
movl 0x5702(%rip), %ebx      # 0xc4e4
leaq 0x56cf(%rip), %r12      # 0xc4b8
movq %r12, %rdi
callq 0x3530
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x31a0
leaq 0x20(%rsp), %rax
movq %rsp, %r8
movq %rax, 0x10(%r8)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%r8)
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x30d0
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34e0
movq %r12, %rdi
callq 0x32c0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5580(%rip), %r14      # 0xc4b8
movq %r14, %rdi
callq 0x3530
movq 0x5029(%rip), %rax      # 0xbf70
movl 0x1e0(%rax), %edx
movl 0x1c4(%rax), %ecx
movl 0x1b0(%rax), %r9d
movl 0x1a8(%rax), %r10d
movl 0x1ac(%rax), %r11d
movl 0x1b4(%rax), %eax
subq $0x8, %rsp
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %r8d
pushq %r10
pushq %rax
pushq %r11
callq 0x31c0
addq $0x20, %rsp
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x5516(%rip), %rdi      # 0xc4b8
callq 0x3530
cmpb $0x1, 0x5532(%rip)      # 0xc4e0
jne 0x6fbd
movq %rbx, %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x3620
leaq 0x54f4(%rip), %rdi      # 0xc4b8
popq %rbx
jmp 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x36a0
movl %eax, 0x53d4(%rip)      # 0xc3b0
xorl %ebx, %ebx
cmpl $-0x1, %eax
sete %cl
setne %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x7036
xorl %ebx, %ebx
movl %eax, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3210
cmpl $-0x1, %eax
je 0x7024
movl 0x53a4(%rip), %edi      # 0xc3b0
orl $0x800, %eax            # imm = 0x800
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3210
cmpl $-0x1, %eax
jne 0x703a
movl 0x5386(%rip), %edi      # 0xc3b0
callq 0x36f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x703a
movb %cl, %bl
negl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rsi
movl 0x5358(%rip), %edi      # 0xc3b0
movl $0x2, %edx
callq 0x31e0
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x708a
leaq 0x5478(%rip), %rdi      # 0xc4e8
movq 0x5479(%rip), %rsi      # 0xc4f0
subq 0x546a(%rip), %rsi      # 0xc4e8
addq $0x110, %rsi            # imm = 0x110
callq 0x7178
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %edi, %esi
movl 0x5319(%rip), %edi      # 0xc3b0
callq 0x3190
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x70c4
leaq 0x543e(%rip), %rdi      # 0xc4e8
movq 0x543f(%rip), %rsi      # 0xc4f0
subq 0x5430(%rip), %rsi      # 0xc4e8
addq $-0x110, %rsi           # imm = 0xFEF0
callq 0x7178
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x5409(%rip), %r15      # 0xc4e8
movl 0x52cb(%rip), %edi      # 0xc3b0
movq 0x5404(%rip), %rdx      # 0xc4f0
subq %r15, %rdx
movq %r15, %rsi
callq 0x3510
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x7141
testl %ebx, %ebx
jle 0x7150
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movslq %eax, %r13
testb $0x2, 0x4(%r15,%r13)
je 0x7130
movl (%r15,%r13), %eax
movl %eax, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x72b6
movl 0xc(%r15,%r13), %eax
addl %r13d, %eax
addl $0x10, %eax
cmpl %ebx, %eax
jl 0x710a
jmp 0x7150
callq 0x3050
xorl %ebx, %ebx
cmpl $0xb, (%rax)
setne %bl
negl %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::ExistingFileValidator::ExistingFileValidator()
ExistingFileValidator() {
        tname = "FILE";
        func = [](const std::string &filename) {
            struct stat buffer;
            bool exist = stat(filename.c_str(), &buffer) == 0;
            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
            if(!exist) {
                return "File does not exist: " + filename;
            } else if(is_dir) {
                return "File is actually a directory: " + filename;
            }
            return std::string();
        };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x1cde7(%rip), %rcx     # 0x230e5
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5460
addq $0x20, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xbd6a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6472
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::ExistingDirectoryValidator::ExistingDirectoryValidator()
ExistingDirectoryValidator() {
        tname = "DIR";
        func = [](const std::string &filename) {
            struct stat buffer;
            bool exist = stat(filename.c_str(), &buffer) == 0;
            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
            if(!exist) {
                return "Directory does not exist: " + filename;
            } else if(!is_dir) {
                return "Directory is actually a file: " + filename;
            }
            return std::string();
        };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x1cdb9(%rip), %rcx     # 0x2311f
movl $0x3, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5460
addq $0x20, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xbeec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6472
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::ExistingPathValidator::ExistingPathValidator()
ExistingPathValidator() {
        tname = "PATH";
        func = [](const std::string &filename) {
            struct stat buffer;
            bool const exist = stat(filename.c_str(), &buffer) == 0;
            if(!exist) {
                return "Path does not exist: " + filename;
            }
            return std::string();
        };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x1cd8f(%rip), %rcx     # 0x2315d
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5460
addq $0x20, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xbfe6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6472
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::NonexistentPathValidator::NonexistentPathValidator()
NonexistentPathValidator() {
        tname = "PATH";
        func = [](const std::string &filename) {
            struct stat buffer;
            bool exist = stat(filename.c_str(), &buffer) == 0;
            if(exist) {
                return "Path already exists: " + filename;
            }
            return std::string();
        };
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x1cd27(%rip), %rcx     # 0x2315d
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x5460
addq $0x20, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xc0d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6472
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_options(std::function<bool (CLI::Option const*)>) const
std::vector<const Option *> get_options(const std::function<bool(const Option *)> filter = {}) const {
        std::vector<const Option *> options(options_.size());
        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
            return val.get();
        });

        if(filter) {
            options.erase(std::remove_if(std::begin(options),
                                         std::end(options),
                                         [&filter](const Option *opt) { return !filter(opt); }),
                          std::end(options));
        }

        return options;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xa0(%rsi), %rsi
subq 0x98(%r15), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
callq 0xc1ba
movq 0x98(%r15), %rax
movq 0xa0(%r15), %rcx
cmpq %rcx, %rax
je 0x7111
movq (%rbx), %rdx
movq (%rax), %rsi
movq %rsi, (%rdx)
addq $0x8, %rax
addq $0x8, %rdx
cmpq %rcx, %rax
jne 0x70fe
cmpq $0x0, 0x10(%r14)
je 0x7146
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xc25f
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x7146
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x7146
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x716a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::ini_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
inline std::string ini_join(std::vector<std::string> args) {
    std::ostringstream s;
    size_t start = 0;
    for(const auto &arg : args) {
        if(start++ > 0)
            s << " ";

        auto it = std::find_if(arg.begin(), arg.end(), [](char ch) { return std::isspace<char>(ch, std::locale()); });
        if(it == arg.end())
            s << arg;
        else if(arg.find(R"(")") == std::string::npos)
            s << R"(")" << arg << R"(")";
        else
            s << R"(')" << arg << R"(')";
    }

    return s.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x53e0
movq (%r15), %r14
movq 0x8(%r15), %rbx
cmpq %rbx, %r14
je 0x732a
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0x1bf57(%rip), %r12     # 0x231bf
leaq 0x1bf52(%rip), %r13     # 0x231c1
subq $0x1, %rbp
jb 0x7289
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1c4dd(%rip), %rsi     # 0x23761
callq 0x5320
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
callq 0xc5d6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq (%rsi,%rdx), %rcx
cmpq %rcx, %rax
je 0x72e4
movl $0x1, %ecx
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x5500
cmpq $-0x1, %rax
je 0x72ee
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x5320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x5320
movq %r13, %rsi
jmp 0x7310
movq %r15, %rdi
callq 0x5320
jmp 0x731d
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x5320
movq %r12, %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x5320
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x726f
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5480
movq 0x28c75(%rip), %rsi     # 0x2ffb8
leaq 0x10(%rsp), %rdi
callq 0x5190
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7373
jmp 0x7373
movq %rax, %rbx
movq 0x28c3b(%rip), %rsi     # 0x2ffb8
leaq 0x10(%rsp), %rdi
callq 0x5190
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_subcommands(std::function<bool (CLI::App const*)> const&) const
std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
        std::vector<const App *> subcomms(subcommands_.size());
        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
            return v.get();
        });

        if(filter) {
            subcomms.erase(std::remove_if(std::begin(subcomms),
                                          std::end(subcomms),
                                          [&filter](const App *app) { return !filter(app); }),
                           std::end(subcomms));
        }

        return subcomms;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x160(%rsi), %rsi
subq 0x158(%r15), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
callq 0xc824
movq 0x158(%r15), %rax
movq 0x160(%r15), %rcx
cmpq %rcx, %rax
je 0x7707
movq (%rbx), %rdx
movq (%rax), %rsi
movq %rsi, (%rdx)
addq $0x8, %rax
addq $0x8, %rdx
cmpq %rcx, %rax
jne 0x76f4
cmpq $0x0, 0x10(%r14)
je 0x773c
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xc8c9
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x773c
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x773c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7760
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5210
leaq 0x40(%rsp), %rdi
leaq 0x1bfc0(%rip), %rsi     # 0x2375d
movl $0x1, %edx
callq 0x5320
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x40(%rsp), %rdi
callq 0x5320
leaq 0x1b8a8(%rip), %rsi     # 0x23068
movl $0x2, %edx
movq %rax, %rdi
callq 0x5320
movq %rbx, 0x8(%rsp)
movq (%r12), %r13
movq 0x8(%r12), %rbx
cmpq %rbx, %r13
je 0x7834
leaq 0x20(%rsp), %r15
movzbl %bpl, %ebp
leaq 0x10(%rsp), %r12
movq (%r13), %rdx
movq (%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq *0x58(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x5320
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x782b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x77ee
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5480
movq 0x2874b(%rip), %rsi     # 0x2ff98
leaq 0x30(%rsp), %rdi
callq 0x5240
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x787b
movq %rax, %rbx
jmp 0x789a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x789a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x286f7(%rip), %rsi     # 0x2ff98
leaq 0x30(%rsp), %rdi
callq 0x5240
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdx, (%rsp)
leaq 0x171eb(%rip), %rax     # 0x1ec80
movq %rax, 0x18(%rsp)
leaq 0x171e5(%rip), %rax     # 0x1ec86
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x68(%rsp), %rdi
movq %rax, %rsi
callq 0x1eb20
leaq 0x88(%rsp), %rdi
movq %rsp, %rsi
callq 0xef2a
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x1eb20
leaq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xeb54
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7b2b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x7b4a
leaq 0x88(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7b61
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bcb9(%rip), %rsi     # 0x2382a
leaq 0x1bcb6(%rip), %rdx     # 0x2382e
leaq 0x28(%rsp), %rdi
callq 0xc794
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ebb0
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x7ba6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7bbd
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7c6f
jmp 0x7c6f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x7c50
movq 0x38(%rsp), %rsi
jmp 0x7c43
jmp 0x7c4d
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7c0e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x7c0e
movq %rax, %rbx
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x7c34
leaq 0x88(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7c34
jmp 0x7c6f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c50
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x7c50
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7c67
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x861b
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::parse(int, char const* const*)
void parse(int argc, const char *const *argv) {
        // If the name is not set, read from command line
        if(name_.empty())
            name_ = argv[0];

        std::vector<std::string> args;
        for(int i = argc - 1; i > 0; i--)
            args.emplace_back(argv[i]);
        parse(args);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
jne 0x832f
leaq 0x8(%rbx), %r12
movq (%r14), %r13
movq %r13, %rdi
callq 0x5160
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x5460
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl %ebp, %eax
leaq (%r14,%rax,8), %rsi
addq $-0x8, %rsi
incl %ebp
decl %ebp
cmpl $0x1, %ebp
jle 0x8365
leaq -0x8(%rsi), %r14
movq %r15, %rdi
callq 0x12c2a
movq %r14, %rsi
jmp 0x834d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12c70
movq %rsp, %rdi
callq 0x7172
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8389
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7172
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_positionals[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_positionals(const App *app) const {
    std::vector<const Option *> opts =
        app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });

    if(opts.empty())
        return std::string();
    else
        return make_group(get_label("Positionals"), true, opts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x13dec(%rip), %rcx     # 0x1c894
movq %rcx, 0x18(%rax)
leaq 0x13df7(%rip), %rcx     # 0x1c8aa
movq %rcx, 0x10(%rax)
movq %rsp, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x70ba
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x8ae1
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x8b96
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ac48(%rip), %rsi     # 0x23748
leaq 0x1ac4c(%rip), %rdx     # 0x23753
leaq 0x30(%rsp), %rdi
callq 0xc794
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r14, %rsi
callq 0x1c7f8
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x1c538
movq (%r14), %rax
leaq 0x50(%rsp), %rdx
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8b62
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b7d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x8ba9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8ba9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8bbf
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8bee
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
jmp 0x8bee
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c0e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8c0e
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x8c2a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8c2a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8c63
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
jmp 0x8c63
jmp 0x8c6b
movq %rax, %rbx
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x8c63
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x861b
nop
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_footer[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_footer(const App *app) const {
    std::string footer = app->get_footer();
    if(!footer.empty())
        return footer + "\n";
    else
        return "";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xb0(%rdx), %rsi
movq 0xb8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1eb20
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x9986
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1eb20
leaq 0x19de1(%rip), %rsi     # 0x2375d
movq %rbx, %rdi
callq 0x5570
jmp 0x999f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19dca(%rip), %rdx     # 0x2375e
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc794
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x99b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x99e0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x99e3
movq (%r12), %rsi
incq %rsi
callq 0x52c0
jmp 0x99e3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x99fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_description[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_description(const App *app) const {
    std::string desc = app->get_description();

    if(!desc.empty())
        return desc + "\n";
    else
        return "";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rdx), %rsi
movq 0x30(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1eb20
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x9a62
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1eb20
leaq 0x19d05(%rip), %rsi     # 0x2375d
movq %rbx, %rdi
callq 0x5570
jmp 0x9a7b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19cee(%rip), %rdx     # 0x2375e
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc794
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9abc
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x9abf
movq (%r12), %rsi
incq %rsi
callq 0x52c0
jmp 0x9abf
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9ad6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_option_name[abi:cxx11](CLI::Option const*, bool) const
inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
    if(is_positional)
        return opt->get_name(true, false);
    else
        return opt->get_name(false, true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %ecx, %ecx
je 0xa512
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x58(%rdx), %rsi
movq 0x60(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1eb20
jmp 0xa524
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xd6b2
movq %rbx, %rax
popq %rbx
retq
nop