LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: SpaceDebug(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SpaceDebug(std::string getData)
{
    // A 2-pointer approach to remove spaces from both ends inside a tag.
    long long int ptr1 = 0, ptr2 = getData.length() - 1;
    while (getData[ptr1] == ' ' || getData[ptr2] == ' ')
    {
        if (getData[ptr1] == ' ')
            ptr1++;
        if (getData[ptr2] == ' ')
            ptr2--;
    }
    return getData.substr(ptr1, ptr2 - ptr1 + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x3370
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3440
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x39(%rbp)
je 0x544e
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3440
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5457
jmp 0x549b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3440
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x5478
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3440
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x5499
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x541b
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
addq $0x1, %rcx
callq 0x3250
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: arrangeDebugger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string arrangeDebugger(std::string getData)
{
    std::string newGetData = "";
    for (int i = 0; i < getData.length(); i++)
    {
        if (getData[i] == '=' || getData[i] == ',')
        {
            newGetData += ' ';
            newGetData += getData[i];
            newGetData += ' ';
        }
        else
        {
            newGetData += getData[i];
        }
    }
    return newGetData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x33e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x7b7d(%rip), %rsi      # 0xd08c
callq 0x9140
jmp 0x5516
leaq -0x12(%rbp), %rdi
callq 0x3280
movl $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x5631
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x58(%rbp)
jmp 0x555a
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x5585
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x60(%rbp)
jmp 0x5579
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x55fa
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x3180
jmp 0x5595
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x68(%rbp)
jmp 0x55a8
movq -0x38(%rbp), %rdi
movq -0x68(%rbp), %rax
movsbl (%rax), %esi
callq 0x3180
jmp 0x55ba
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x3180
jmp 0x55ca
jmp 0x5621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3280
jmp 0x564e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3170
jmp 0x564e
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x70(%rbp)
jmp 0x560d
movq -0x38(%rbp), %rdi
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
callq 0x3180
jmp 0x561f
jmp 0x5621
jmp 0x5623
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5526
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5644
movq -0x38(%rbp), %rdi
callq 0x3170
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<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::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::dumpDebug(std::ostream&) const
void dumpDebug(std::ostream& os) const {
		ScopedLock scoped(m_lock);
		std::cout << "Cache Size : " << m_cache.size() << " (max:" << m_maxSize
				<< ") (elasticity: " << m_elasticity << ")" << std::endl;
		for (Node<Key, Value>* node = m_keys.head; node != NULL; node = node->next) {
			printVisitor(*node);
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x3770
movq 0x71e9(%rip), %rdi      # 0x9fd8
leaq 0x32c5(%rip), %rsi      # 0x60bb
callq 0x2180
movq %rax, -0x40(%rbp)
jmp 0x2e01
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x4dc0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2070
movq %rax, -0x50(%rbp)
jmp 0x2e20
movq -0x50(%rbp), %rdi
leaq 0x329e(%rip), %rsi      # 0x60c9
callq 0x2180
movq %rax, -0x58(%rbp)
jmp 0x2e36
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x2070
movq %rax, -0x60(%rbp)
jmp 0x2e4d
movq -0x60(%rbp), %rdi
leaq 0x3278(%rip), %rsi      # 0x60d0
callq 0x2180
movq %rax, -0x68(%rbp)
jmp 0x2e63
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x2070
movq %rax, -0x70(%rbp)
jmp 0x2e7a
movq -0x70(%rbp), %rdi
leaq 0x325b(%rip), %rsi      # 0x60e0
callq 0x2180
movq %rax, -0x78(%rbp)
jmp 0x2e90
movq -0x78(%rbp), %rdi
movq 0x7125(%rip), %rsi      # 0x9fc0
callq 0x21c0
jmp 0x2ea2
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2ee7
movq -0x38(%rbp), %rdi
callq 0x55f0
jmp 0x2ec0
jmp 0x2ec2
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2eae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bc0
jmp 0x2ef9
leaq -0x20(%rbp), %rdi
callq 0x3bc0
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<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::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value& get(const Key& key) {
		ScopedLock scoped(m_lock);
		typename MapType::iterator iter = m_cache.find(key);
		if (iter == m_cache.end()) {
			throw KeyNotFound();
		}
		m_keys.remove(iter->second);
		m_keys.push(iter->second);
		return iter->second->value;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x3770
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x37b0
movq %rax, -0x48(%rbp)
jmp 0x2f4c
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x3810
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d90
testb $0x1, %al
jne 0x2f78
jmp 0x2fc8
movl $0x8, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, (%rdi)
callq 0x5670
movq -0x58(%rbp), %rdi
leaq 0x6dc8(%rip), %rsi      # 0x9d68
leaq 0x2709(%rip), %rdx      # 0x56b0
callq 0x2260
jmp 0x303f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bc0
jmp 0x3036
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3840
movq -0x60(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x3860
jmp 0x2fec
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3840
movq -0x70(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x38e0
leaq -0x28(%rbp), %rdi
callq 0x3840
movq 0x20(%rax), %rax
addq $0x38, %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bc0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2270
nop
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clear()
void clear() {
		if (head) {
			delete head;
		}
		head = 0;
		tail = 0;
		size = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x33d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x33d7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x33d9
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove(lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
Node<Key, Value>* remove(Node<Key, Value>* node) {
		if (node == head) {
			head = node->next;
		}
		if (node == tail) {
			tail = node->prev;
		}
		node->unlink();
		size--;
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x3892
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jne 0x38b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x3f40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::push(lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void push(Node<Key, Value>* node) {
		node->unlink();
		if (!head) {
			head = node;
		} else if (head == tail) {
			head->next = node;
			node->prev = head;
		} else {
			tail->next = node;
			node->prev = tail;
		}
		tail = node;
		size++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f40
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x391a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3964
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x3946
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3962
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x10(%rax), %rcx
movq %rdx, 0x10(%rcx)
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3964
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<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::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::prune()
size_t prune() {
		if (m_maxSize > 0 && m_cache.size() >= (m_maxSize + m_elasticity)) {
			size_t count = 0;
			while (m_cache.size() > m_maxSize) {
				Node<Key, Value>* n = m_keys.pop();
				m_cache.erase(n->key);
				delete n;
				count++;
			}
			return count;
		} else {
			return 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x60(%rax)
jbe 0x3ba2
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x4dc0
movq -0x28(%rbp), %rdx
movq 0x60(%rdx), %rcx
addq 0x68(%rdx), %rcx
cmpq %rcx, %rax
jb 0x3ba2
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x4dc0
movq -0x28(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jbe 0x3b98
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x4de0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
callq 0x4e70
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3b8a
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3b35
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3baa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::unlink()
void unlink() {
		if (next) {
			next->prev = prev;
		}
		if (prev) {
			prev->next = next;
		}
		next = 0;
		prev = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x3f67
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f82
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::cleanup()
void cleanup() {
		if (next) {
			delete next;
		}
		next = 0;
		prev = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x4059
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4057
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4059
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pop()
Node<Key, Value>* pop() {
		if (!head) {
			return 0;
		} else {
			Node<Key, Value>* newHead = head->next;
			head->unlink();
			Node<Key, Value>* oldHead = head;
			head = newHead;
			size--;
			if (size == 0) {
				tail = 0;
			}
			return oldHead;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4e05
movq $0x0, -0x8(%rbp)
jmp 0x4e59
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x3f40
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x4e51
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: canonify_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string
canonify_filename(string filename)
{
 size_t pos = 0;

 // remove double slashes
 if ((pos = filename.find("//", 0)) < filename.size())
  filename.replace(pos, 2, "/");

 if (filename[0] != '~')
  return filename;

 // resolve home directory
 return string(getenv("HOME")) + filename.substr(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq %rax, %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xb40d(%rip), %rsi      # 0x1001b
xorl %eax, %eax
movl %eax, %edx
callq 0x47f0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rax, -0x18(%rbp)
callq 0x42c0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x4c4d
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
leaq 0xb3d4(%rip), %rcx      # 0x1001c
callq 0x4260
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4800
movsbl (%rax), %eax
cmpl $0x7e, %eax
je 0x4c77
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x4250
jmp 0x4d46
leaq 0xb3a0(%rip), %rdi      # 0x1001e
callq 0x44e0
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4740
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5e40
jmp 0x4cb3
movq -0x80(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x4400
jmp 0x4cce
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x5ef0
jmp 0x4ce4
leaq -0x70(%rbp), %rdi
callq 0x4828
leaq -0x38(%rbp), %rdi
callq 0x4828
leaq -0x39(%rbp), %rdi
callq 0x4450
jmp 0x4d46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4d3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4d32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4828
leaq -0x38(%rbp), %rdi
callq 0x4828
leaq -0x39(%rbp), %rdi
callq 0x4450
jmp 0x4d56
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4730
nop
// File: Linkerist[P]xs/src/xs.cc
// Function: xmalloc(unsigned long)
void *
xmalloc(size_t n)
{
 void * p = malloc(n);
 if (!p && n != 0) {
  fprintf(stderr, "memory exhausted\n");
  abort();
 }

 return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x50e4
cmpq $0x0, -0x8(%rbp)
je 0x50e4
movq 0x11efa(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
leaq 0xaf53(%rip), %rsi      # 0x1002b
movb $0x0, %al
callq 0x45d0
callq 0x4230
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Linkerist[P]xs/src/xs.cc
// Function: abort_xs()
void
abort_xs(void)
{
 curs_set(1); // re-show cursor (FIXME: necessary?)
 clear();
 refresh();   // ..and make sure we really see the clean screen
 //resetty();   // ??
 endwin();    // finish the curses at all
 exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
callq 0x4330
callq 0x4720
callq 0x4700
callq 0x44a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x44d0
nopw (%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: get_cwd_as_charp()
char *
get_cwd_as_charp(void)
{
 char * buf;
 char * result = NULL;
 size_t size = (size_t)pathconf(".", _PC_PATH_MAX);

 buf = (char *)xmalloc(size);
 result = getcwd(buf, size);
 if (result == NULL) {
  message("cannot determine current working directory.exit.");
  sleep(1);
  abort_xs();
 }

 result = strdup(buf);
 free(buf);

 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
leaq 0xb061(%rip), %rdi      # 0x10198
movl $0x4, %esi
callq 0x4680
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x50a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4210
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5185
leaq 0xaecc(%rip), %rdi      # 0x1003d
callq 0xe7a0
movl $0x1, %edi
callq 0x4300
callq 0x50f0
movq -0x8(%rbp), %rdi
callq 0x4770
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: get_cwd_as_string[abi:cxx11]()
string
get_cwd_as_string(void)
{
 char * cwd = get_cwd_as_charp();
 if (cwd == NULL)
  return "";
 else {
  string result = string(cwd);
  free(cwd);
  return result;
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x5120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x521f
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4740
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xb187(%rip), %rsi      # 0x1037a
callq 0x5e40
jmp 0x51fa
leaq -0x11(%rbp), %rdi
callq 0x4450
jmp 0x528b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4450
jmp 0x5295
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4740
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x5e40
jmp 0x524b
leaq -0x26(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rdi
callq 0x44c0
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x5289
jmp 0x5280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x4450
jmp 0x5295
movq -0x38(%rbp), %rdi
callq 0x4828
jmp 0x528b
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4730
nop
// File: Linkerist[P]xs/src/xs.cc
// Function: valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, pathtype)
bool
valid(string path, pathtype mode)
{
 struct stat buf;
 string canon_path = canonify_filename(path);

 if(mode == PATH_IS_FILE) {
  stat(canon_path.c_str(), &buf);
  if (S_ISREG(buf.st_mode))
   return true;
 } else if (mode == PATH_IS_DIR) {
  stat(canon_path.c_str(), &buf);
  if (S_ISDIR(buf.st_mode))
   return true;
 }

 return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x41b0
movq -0x100(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x4bd0
jmp 0x52df
leaq -0xe8(%rbp), %rdi
callq 0x4828
cmpl $0x0, -0x14(%rbp)
jne 0x5350
leaq -0xc8(%rbp), %rdi
callq 0x41a0
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x43a0
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x534e
movb $0x1, -0x1(%rbp)
movl $0x1, -0xf8(%rbp)
jmp 0x53a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x4828
jmp 0x53bf
jmp 0x5397
cmpl $0x1, -0x14(%rbp)
jne 0x5395
leaq -0xc8(%rbp), %rdi
callq 0x41a0
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x43a0
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x5393
movb $0x1, -0x1(%rbp)
movl $0x1, -0xf8(%rbp)
jmp 0x53a5
jmp 0x5395
jmp 0x5397
movb $0x0, -0x1(%rbp)
movl $0x1, -0xf8(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4828
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x4730
nopl (%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: terminate(int)
void
terminate(int signo)
{
 endwin();

 if (signo == 11) {
  fprintf(stderr, "program received signal %d\n", signo);
  fprintf(stderr, "This should never happen.\n");
  fprintf(stderr, "Maybe you want to send an email to the author and report a bug?\n");
  fprintf(stderr, "Author: Linkerist <Linkerist@163.com>\n"); 
 }

 fprintf(stderr, "abort.\n");
 exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x44a0
cmpl $0xb, -0x4(%rbp)
jne 0x56d9
movq 0x1194b(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0xaa07(%rip), %rsi      # 0x10091
movb $0x0, %al
callq 0x45d0
movq 0x11930(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
leaq 0xaa0b(%rip), %rsi      # 0x100ad
movb $0x0, %al
callq 0x45d0
movq 0x11918(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
leaq 0xaa0e(%rip), %rsi      # 0x100c8
movb $0x0, %al
callq 0x45d0
movq 0x11900(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
leaq 0xaa37(%rip), %rsi      # 0x10109
movb $0x0, %al
callq 0x45d0
movq 0x118e8(%rip), %rax     # 0x16fc8
movq (%rax), %rdi
leaq 0xaa46(%rip), %rsi      # 0x10130
movb $0x0, %al
callq 0x45d0
movl $0x1, %edi
callq 0x44d0
nopl (%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: resizeevent(int)
void
resizeevent(int signo)
{
 (void)signo;

 // re-connect
 signal(SIGWINCH, resizeevent);
 
 // FIXME: is this the correct way??
 endwin();
 refresh();
 init_curses();
 display_list();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1c, %edi
leaq -0x17(%rip), %rsi       # 0x5700
callq 0x44b0
callq 0x44a0
callq 0x4700
callq 0xc950
callq 0xe830
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: visible(int)
bool
visible(int pos)
{
 if(pos < 0)
  return false;

 if(pos - yoffset < 0)
  return false;

 if(pos + yoffset > display_area_ymax)
  return false;

 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x5753
movb $0x0, -0x1(%rbp)
jmp 0x578b
movl -0x8(%rbp), %eax
leaq 0x11ecf(%rip), %rcx     # 0x1762c
subl (%rcx), %eax
cmpl $0x0, %eax
jge 0x576a
movb $0x0, -0x1(%rbp)
jmp 0x578b
movl -0x8(%rbp), %eax
leaq 0x11eb8(%rip), %rcx     # 0x1762c
addl (%rcx), %eax
leaq 0x11e9f(%rip), %rcx     # 0x1761c
cmpl (%rcx), %eax
jle 0x5787
movb $0x0, -0x1(%rbp)
jmp 0x578b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/xs.cc
// Function: max_yoffset()
int
max_yoffset(void)
{
 int len, ret;

 if (mode == BROWSE)
  len = cur_list.size() - 1;
 else
  len = default_list.size() - 1;

 ret = len - display_area_ymax;
 return ret < 0 ? 0 : ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x1, 0x11db9(%rip)     # 0x17598
jne 0x57f6
leaq 0x11d40(%rip), %rdi     # 0x17528
callq 0x61f0
subq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0x5809
leaq 0x11d43(%rip), %rdi     # 0x17540
callq 0x61f0
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x11e09(%rip), %rcx     # 0x1761c
subl (%rcx), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x5825
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x582b
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/io.cc
// Function: dont_show(char const*)
bool
dont_show(const char * name)
{
 /* don't show current, up, hidden if not flag */
 if (mode == BROWSE) {
  if (strcmp(name, "..") == 0)
   return true;
  
  if (!show_hidden_files && name[0] == '.')
   return true;
 } else {
  if (!NeedleGiven)
   return false;

  if (!Needle)
   return false;

  /* FIXME case-insensitive comparison */
  //if (strcasecmp(name, Needle)) {
  return !strstr(name, Needle);
 }

 return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x103e5(%rip), %rax     # 0x17598
cmpl $0x1, (%rax)
jne 0x71f3
movq -0x10(%rbp), %rdi
leaq 0x8fd4(%rip), %rsi      # 0x10197
callq 0x45a0
cmpl $0x0, %eax
jne 0x71d3
movb $0x1, -0x1(%rbp)
jmp 0x723f
leaq 0x103c2(%rip), %rax     # 0x1759c
testb $0x1, (%rax)
jne 0x71f1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x71f1
movb $0x1, -0x1(%rbp)
jmp 0x723f
jmp 0x723b
leaq 0x10366(%rip), %rax     # 0x17560
testb $0x1, (%rax)
jne 0x7205
movb $0x0, -0x1(%rbp)
jmp 0x723f
leaq 0x1034c(%rip), %rax     # 0x17558
cmpq $0x0, (%rax)
jne 0x7218
movb $0x0, -0x1(%rbp)
jmp 0x723f
movq -0x10(%rbp), %rdi
leaq 0x10335(%rip), %rax     # 0x17558
movq (%rax), %rsi
callq 0x40e0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x723f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Linkerist[P]xs/src/io.cc
// Function: cur_pos_adjust(int, bool)
void
cur_pos_adjust(int n, bool wrap_around)
{
 int newpos = CurrPosition + n;
 int max, min;

 if (mode == LIST)
  max = default_list.size() - 1;
 else
  max = cur_list.size() - 1;

 min = 0;

 if (newpos < min) {
  if (opt_no_wrap || !wrap_around)
   return;

  newpos = max;
  yoffset = max_yoffset();
 }

 if (newpos > max) {
  if (opt_no_wrap || !wrap_around)
   return;

  newpos = min;
  yoffset = 0;
 }

 CurrPosition = newpos;
 // scrolling...
 if (CurrPosition-yoffset >= display_area_ymax)
  ++yoffset;

 if (yoffset > 0 && CurrPosition == yoffset)
  --yoffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
leaq 0xf51a(%rip), %rax      # 0x17564
movl (%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0xf53f(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0x8073
leaq 0xf4db(%rip), %rdi      # 0x17540
callq 0x61f0
subq $0x1, %rax
movl %eax, -0x10(%rbp)
jmp 0x8086
leaq 0xf4ae(%rip), %rdi      # 0x17528
callq 0x61f0
subq $0x1, %rax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x80c2
leaq 0xf501(%rip), %rax      # 0x1759d
testb $0x1, (%rax)
jne 0x80a7
testb $0x1, -0x5(%rbp)
jne 0x80ac
jmp 0x8167
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x57d0
movl %eax, %ecx
leaq 0xf56c(%rip), %rax      # 0x1762c
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x80f4
leaq 0xf4cc(%rip), %rax      # 0x1759d
testb $0x1, (%rax)
jne 0x80dc
testb $0x1, -0x5(%rbp)
jne 0x80e1
jmp 0x8167
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0xf53e(%rip), %rax      # 0x1762c
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
leaq 0xf466(%rip), %rax      # 0x17564
movl %ecx, (%rax)
leaq 0xf45d(%rip), %rax      # 0x17564
movl (%rax), %eax
leaq 0xf51c(%rip), %rcx      # 0x1762c
subl (%rcx), %eax
leaq 0xf503(%rip), %rcx      # 0x1761c
cmpl (%rcx), %eax
jl 0x8132
leaq 0xf508(%rip), %rax      # 0x1762c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xf4fc(%rip), %rax      # 0x1762c
movl %ecx, (%rax)
leaq 0xf4f3(%rip), %rax      # 0x1762c
cmpl $0x0, (%rax)
jle 0x8167
leaq 0xf41f(%rip), %rax      # 0x17564
movl (%rax), %eax
leaq 0xf4de(%rip), %rcx      # 0x1762c
cmpl (%rcx), %eax
jne 0x8167
leaq 0xf4d3(%rip), %rax      # 0x1762c
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0xf4c7(%rip), %rax      # 0x1762c
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Linkerist[P]xs/src/io.cc
// Function: entry_nr_exists(unsigned int)
bool
entry_nr_exists(unsigned int nr)
{
 if (mode == LIST)
  return nr < default_list.size();
 else if (mode == BROWSE)
  return nr < cur_list.size();

 return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0xf416(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0x81ae
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
leaq 0xf3ab(%rip), %rdi      # 0x17540
callq 0x61f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x81e7
leaq 0xf3e3(%rip), %rax      # 0x17598
cmpl $0x1, (%rax)
jne 0x81e1
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
leaq 0xf360(%rip), %rdi      # 0x17528
callq 0x61f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x81e7
jmp 0x81e3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/io.cc
// Function: current_entry[abi:cxx11]()
string
current_entry(void)
{
 string res;

 if (mode == LIST) {
  if (default_list.empty())
   return ".";

  res = default_list[CurrPosition].second;
 } else if (mode == BROWSE) {
  if (cur_list.empty())
   return string(".");

  res = cur_list[CurrPosition].second;
 }

 return res == "" ? "." : res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4590
leaq 0xf36e(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0x82d5
leaq 0xf306(%rip), %rdi      # 0x17540
callq 0x8b50
testb $0x1, %al
jne 0x8245
jmp 0x8297
leaq -0x29(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4740
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x7f37(%rip), %rsi      # 0x10198
callq 0x5e40
jmp 0x8268
leaq -0x29(%rbp), %rdi
callq 0x4450
movl $0x1, -0x40(%rbp)
jmp 0x840a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4450
jmp 0x8420
leaq 0xf2c6(%rip), %rax      # 0x17564
movslq (%rax), %rsi
leaq 0xf298(%rip), %rdi      # 0x17540
callq 0x8e40
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4050
jmp 0x82bf
jmp 0x8375
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8420
leaq 0xf2bc(%rip), %rax      # 0x17598
cmpl $0x1, (%rax)
jne 0x8373
leaq 0xf23c(%rip), %rdi      # 0x17528
callq 0x8b50
testb $0x1, %al
jne 0x82f7
jmp 0x8349
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4740
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x7e85(%rip), %rsi      # 0x10198
callq 0x5e40
jmp 0x831a
leaq -0x41(%rbp), %rdi
callq 0x4450
movl $0x1, -0x40(%rbp)
jmp 0x840a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x4450
jmp 0x8420
leaq 0xf214(%rip), %rax      # 0x17564
movslq (%rax), %rsi
leaq 0xf1ce(%rip), %rdi      # 0x17528
callq 0x8e40
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4050
jmp 0x8371
jmp 0x8373
jmp 0x8375
movb $0x0, -0x43(%rbp)
leaq 0x7ffa(%rip), %rsi      # 0x1037a
leaq -0x28(%rbp), %rdi
callq 0x6210
movb %al, -0x69(%rbp)
jmp 0x838e
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x8397
jmp 0x83c0
leaq -0x42(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4740
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rdx
movb $0x1, -0x43(%rbp)
leaq 0x7de1(%rip), %rsi      # 0x10198
callq 0x5e40
jmp 0x83be
jmp 0x83d1
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41b0
jmp 0x83cf
jmp 0x83d1
testb $0x1, -0x43(%rbp)
jne 0x83d9
jmp 0x83e2
leaq -0x42(%rbp), %rdi
callq 0x4450
movl $0x1, -0x40(%rbp)
jmp 0x840a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x43(%rbp)
jne 0x83ff
jmp 0x8408
leaq -0x42(%rbp), %rdi
callq 0x4450
jmp 0x8420
leaq -0x28(%rbp), %rdi
callq 0x4828
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4828
movq -0x38(%rbp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/io.cc
// Function: delete_from_default_list(int)
void
delete_from_default_list(int pos)
{
 int count = 0;
 for (listit li = default_list.begin();li != default_list.end(); ++li) {
  if (count == pos) {
   default_list.erase(li);
   cur_pos_adjust(0, false);
   opt_no_resolve = true;
   return;
  } else
   ++count;
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq 0xee07(%rip), %rdi      # 0x17540
callq 0x8c20
movq %rax, -0x10(%rbp)
leaq 0xedf7(%rip), %rdi      # 0x17540
callq 0x8c50
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8dc0
testb $0x1, %al
jne 0x8765
jmp 0x87b9
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x87a3
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8ed0
movq -0x20(%rbp), %rsi
leaq 0xedbb(%rip), %rdi      # 0x17540
callq 0x8e60
movq %rax, -0x28(%rbp)
xorl %esi, %esi
movl %esi, %edi
callq 0x8030
leaq 0xee00(%rip), %rax      # 0x1759e
movb $0x1, (%rax)
jmp 0x87b9
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x87ae
leaq -0x10(%rbp), %rdi
callq 0x8e20
jmp 0x8742
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Linkerist[P]xs/src/io.cc
// Function: edit_list_file()
void
edit_list_file(void)
{
 string editor = getenv("EDITOR");
 if (editor.empty()) {
  // FIXME: how to detect debian and the /usr/bin/editor rule?
  struct stat buf;
  if (stat("/usr/bin/editor", &buf) == 0)
   editor = "/usr/bin/editor";
  else
   editor = "vi";
 }

 endwin();
 list_to_file();
 if(system((editor + " \"" + get_listfile() + "\"").c_str())){};
 list_from_file();
 refresh();
 init_curses();
 display_list();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
leaq 0x87ff(%rip), %rdi      # 0x10fd1
callq 0x44e0
movq %rax, -0x158(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x4740
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x5e40
jmp 0x8807
leaq -0x21(%rbp), %rdi
callq 0x4450
leaq -0x20(%rbp), %rdi
callq 0x46f0
testb $0x1, %al
jne 0x881f
jmp 0x888c
leaq 0x79e7(%rip), %rdi      # 0x1020d
leaq -0xc8(%rbp), %rsi
callq 0x43a0
cmpl $0x0, %eax
jne 0x8876
leaq 0x79cf(%rip), %rsi      # 0x1020d
leaq -0x20(%rbp), %rdi
callq 0x4580
jmp 0x8849
jmp 0x888a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4450
jmp 0x89f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x89e8
leaq 0x79a0(%rip), %rsi      # 0x1021d
leaq -0x20(%rbp), %rdi
callq 0x4580
jmp 0x8888
jmp 0x888a
jmp 0x888c
callq 0x44a0
jmp 0x8893
callq 0x7d20
jmp 0x889a
leaq 0x797f(%rip), %rdx      # 0x10220
leaq -0x128(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6010
jmp 0x88b3
leaq -0x148(%rbp), %rdi
callq 0x4d60
jmp 0x88c1
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rsi
leaq -0x148(%rbp), %rdx
callq 0x5ef0
jmp 0x88dd
leaq 0x793d(%rip), %rdx      # 0x10221
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x6090
jmp 0x88f9
leaq -0xe8(%rbp), %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x4350
movl %eax, -0x15c(%rbp)
jmp 0x8915
leaq -0xe8(%rbp), %rdi
callq 0x4828
leaq -0x108(%rbp), %rdi
callq 0x4828
leaq -0x148(%rbp), %rdi
callq 0x4828
leaq -0x128(%rbp), %rdi
callq 0x4828
movl -0x15c(%rbp), %eax
cmpl $0x0, %eax
je 0x89ba
jmp 0x89ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x89ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x89a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x8994
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x4828
leaq -0x108(%rbp), %rdi
callq 0x4828
leaq -0x148(%rbp), %rdi
callq 0x4828
leaq -0x128(%rbp), %rdi
callq 0x4828
jmp 0x89e8
callq 0x6c60
jmp 0x89c1
callq 0x4700
jmp 0x89c8
callq 0xc950
jmp 0x89cf
callq 0xe830
jmp 0x89d6
leaq -0x20(%rbp), %rdi
callq 0x4828
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x4828
movq -0x30(%rbp), %rdi
callq 0x4730
nopw (%rax,%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: set_areas()
void
set_areas(void)
{
 getmaxyx(stdscr, terminal_height, terminal_width); // get win-dims
 xmax = terminal_width - 1;
 display_area_ymin = 0;
 display_area_ymax = terminal_height - 3;
 modeliney = terminal_height - 2;
 msg_area_y = terminal_height - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0xa723(%rip), %rcx      # 0x16fc0
cmpq (%rcx), %rax
je 0xc8b8
movq 0xa717(%rip), %rax      # 0x16fc0
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc8c2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x4(%rbp)
jmp 0xc8c2
movl -0x4(%rbp), %eax
movl %eax, 0xad49(%rip)      # 0x17614
xorl %eax, %eax
movq 0xa6ec(%rip), %rcx      # 0x16fc0
cmpq (%rcx), %rax
je 0xc8ef
movq 0xa6e0(%rip), %rax      # 0x16fc0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc8f9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x8(%rbp)
jmp 0xc8f9
movl -0x8(%rbp), %eax
movl %eax, 0xad0e(%rip)      # 0x17610
movl 0xad08(%rip), %eax      # 0x17610
subl $0x1, %eax
movl %eax, 0xad07(%rip)      # 0x17618
movl $0x0, 0xad05(%rip)      # 0x17620
movl 0xacf3(%rip), %eax      # 0x17614
subl $0x3, %eax
movl %eax, 0xacf2(%rip)      # 0x1761c
movl 0xace4(%rip), %eax      # 0x17614
subl $0x2, %eax
movl %eax, 0xaceb(%rip)      # 0x17624
movl 0xacd5(%rip), %eax      # 0x17614
subl $0x1, %eax
movl %eax, 0xace0(%rip)      # 0x17628
popq %rbp
retq
nopw (%rax,%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: init_curses()
void
init_curses(void)
{
 initscr();               // init curses screen
 //savetty();             // ??
 nonl();                  // no newline
 cbreak();                // not in cooked mode: char immediately available
 noecho();                // chars are not echoed
 keypad(stdscr, true);    // Arrow keys etc
 leaveok(stdscr, TRUE);   // Don't show the...
 curs_set(0);             // ...cursor
 set_areas();

 curses_running = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4620
callq 0x4550
callq 0x4130
callq 0x4490
movq 0xa651(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x4170
movq 0xa63d(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x45e0
xorl %edi, %edi
callq 0x4330
callq 0xc890
movb $0x1, 0xac8d(%rip)      # 0x17630
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: toggle_mode()
void
toggle_mode(void)
{
 if (mode == LIST) {
  mode = BROWSE;
  list_from_dir(".");
 } else {
  // list was empty at start
  if (listfile_empty) {
   if (!default_list.empty()) {
	// but isn't now
	list_to_file();
	list_from_file();
	mode = LIST;
   } else {
	// ok, we have nothing to show here
	message("No List entry. Staying in BROWSE mode");
	mode = BROWSE;
	list_from_dir(".");
   }
  } else {
   // the "normal" case;
   // disable Needle and reload the list!
   NeedleGiven = false;
   Needle = NULL;
   list_from_file();
   yoffset = 0;
   shorties_offset = 0;
   CurrPosition = 0;
   mode = LIST;
  }
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xa1bd(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0xd3fe
leaq 0xa1b1(%rip), %rax      # 0x17598
movl $0x1, (%rax)
leaq 0x2da4(%rip), %rdi      # 0x10198
callq 0x7250
jmp 0xd4a7
leaq 0xa19a(%rip), %rax      # 0x1759f
testb $0x1, (%rax)
je 0xd45a
leaq 0xa12f(%rip), %rdi      # 0x17540
callq 0x8b50
testb $0x1, %al
jne 0xd433
callq 0x7d20
callq 0x6c60
leaq 0xa16d(%rip), %rax      # 0x17598
movl $0x0, (%rax)
jmp 0xd458
leaq 0x3eb8(%rip), %rdi      # 0x112f2
callq 0xe7a0
leaq 0xa152(%rip), %rax      # 0x17598
movl $0x1, (%rax)
leaq 0x2d45(%rip), %rdi      # 0x10198
callq 0x7250
jmp 0xd4a5
leaq 0xa0ff(%rip), %rax      # 0x17560
movb $0x0, (%rax)
leaq 0xa0ed(%rip), %rax      # 0x17558
movq $0x0, (%rax)
callq 0x6c60
movl $0x0, 0xa1ab(%rip)      # 0x1762c
movl $0x0, 0xa1a9(%rip)      # 0x17634
leaq 0xa0d2(%rip), %rax      # 0x17564
movl $0x0, (%rax)
leaq 0xa0f9(%rip), %rax      # 0x17598
movl $0x0, (%rax)
jmp 0xd4a7
popq %rbp
retq
nopl (%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: swap_two_entries(int)
void
swap_two_entries(int advance_afterwards)
{
 int switch_index;
 if (advance_afterwards >= 0)
  switch_index = CurrPosition + 1;
 else
  switch_index = CurrPosition - 1;

 // ranges check:
 if (switch_index > int(default_list.size()) || switch_index < 0) {
  beep();
  return;
 }

 if (mode == LIST && !NeedleGiven) {
  pair<string, string> tmp = default_list[CurrPosition];
  default_list[CurrPosition] = default_list[switch_index];
  default_list[switch_index] = tmp;
  cur_pos_adjust(advance_afterwards);
  display_list();
 } else
  beep();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xe672
leaq 0x8efc(%rip), %rax      # 0x17564
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xe681
leaq 0x8eeb(%rip), %rax      # 0x17564
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq 0x8eb2(%rip), %rdi      # 0x17540
callq 0x61f0
movq %rax, %rcx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jg 0xe6a3
cmpl $0x0, -0x8(%rbp)
jge 0xe6ad
callq 0x40c0
jmp 0xe784
leaq 0x8ee4(%rip), %rax      # 0x17598
cmpl $0x0, (%rax)
jne 0xe77f
leaq 0x8e9c(%rip), %rax      # 0x17560
testb $0x1, (%rax)
jne 0xe77f
leaq 0x8e90(%rip), %rax      # 0x17564
movq %rax, -0x68(%rbp)
movslq (%rax), %rsi
leaq 0x8e5e(%rip), %rdi      # 0x17540
movq %rdi, -0x70(%rbp)
callq 0x8e40
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xf160
movq -0x70(%rbp), %rdi
movslq -0x8(%rbp), %rsi
callq 0x8e40
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x60(%rbp)
movslq (%rax), %rsi
callq 0x8e40
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0xf1c0
jmp 0xe729
movslq -0x8(%rbp), %rsi
leaq 0x8e0c(%rip), %rdi      # 0x17540
callq 0x8e40
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0xf1c0
jmp 0xe747
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x8030
jmp 0xe756
callq 0xe830
jmp 0xe75d
leaq -0x48(%rbp), %rdi
callq 0x6850
jmp 0xe784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6850
jmp 0xe78a
callq 0x40c0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4730
nopw %cs:(%rax,%rax)
// File: Linkerist[P]xs/src/ui.cc
// Function: message(char const*)
void
message(const char * msg)
{
 if (curses_running) {
  move(msg_area_y, 0);
  clrtoeol();
  printw("%s [any key to continue]", msg);
  refresh();
  getch();
  move(msg_area_y, 0);
  clrtoeol();
 } else
  printf("%s\n", msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x8e7d(%rip)      # 0x17630
je 0xe815
movl 0x8e6d(%rip), %edi      # 0x17628
xorl %esi, %esi
callq 0x42d0
movq 0x87f7(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
callq 0x4440
movq -0x8(%rbp), %rsi
leaq 0x25be(%rip), %rdi      # 0x10d9a
movb $0x0, %al
callq 0x43e0
callq 0x4700
movq 0x87d1(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
callq 0x4160
movl 0x8e2b(%rip), %edi      # 0x17628
xorl %esi, %esi
callq 0x42d0
movq 0x87b5(%rip), %rax      # 0x16fc0
movq (%rax), %rdi
callq 0x4440
jmp 0xe827
movq -0x8(%rbp), %rsi
leaq 0x186d(%rip), %rdi      # 0x1008d
movb $0x0, %al
callq 0x4060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)