LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/main.cpp
// Function: main
int main()
{
	DEBUG = false;


	while (1) {
		cout << "[u1851977@localhost " + globalUser.u_curdir + "]$ ";
		getline(cin, line);

		vector<string> cmdList = getCmd(line); // ��ʱ��һ����Ϊ������

		exeCmd(cmdList);

	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movb $0x0, 0x49b1(%rip)      # 0xd251
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %r13
leaq -0xa0(%rbp), %r14
leaq -0x88(%rbp), %r12
movq %r12, %rdi
leaq 0xb0d(%rip), %rsi       # 0x93cd
leaq 0x163b9(%rip), %rdx     # 0x1ec80
callq 0x8a70
movq %r12, %rdi
leaq 0xb0c(%rip), %rsi       # 0x93e2
callq 0x3410
movq %r15, -0x48(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x88fb
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x8902
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x46a0(%rip), %rdi      # 0xcfc8
callq 0x3260
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x8942
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %r15, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x8961
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x4678(%rip), %r15      # 0xcfe0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %edx
movq %r15, %rdi
leaq 0x16677(%rip), %rsi     # 0x1f000
callq 0x3400
leaq -0x58(%rbp), %r12
movq %r12, -0x68(%rbp)
movq 0x16663(%rip), %rsi     # 0x1f000
movq 0x16664(%rip), %rdx     # 0x1f008
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x77a6
movq %r13, %rdi
movq %r15, %rsi
callq 0x7840
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x89d3
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3220
movq %r14, %rdi
movq %r13, %rsi
callq 0x8b02
movq %rbx, %r15
movq %r14, %rdi
callq 0x7a50
movq %r14, %rdi
callq 0x84e4
movq %r13, %rdi
callq 0x84e4
jmp 0x88af
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x84e4
jmp 0x8a12
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x84e4
jmp 0x8a68
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x8a68
movq -0x58(%rbp), %rsi
jmp 0x8a60
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x8a4c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
jmp 0x8a4c
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x8a68
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: removeFrontSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string removeFrontSpaces(std::string getData)
{
    for (int i = 0; i < getData.length(); i++)
    {
        if (getData[i] != ' ')
        {
            getData = getData.substr(i, getData.length() - i);
            break;
        }
    }
    return getData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x28e2
movq (%rbx), %rax
xorl %edx, %edx
cmpb $0x20, (%rax,%rdx)
jne 0x28ad
incq %rdx
cmpq %rdx, %rcx
jne 0x289d
jmp 0x28e2
subq %rdx, %rcx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x28e2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2180
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x2901
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x2907
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: writeCode()
void writeCode()
{
    std::ofstream writeFile("output.c");
    for (int i = 0; i < setParserData.size() - 1; i++)
    {
        writeFile << setParserData[i] << "\n";
        if (i == 0)
        {
            for (int k = 0; k < functionHeader.size(); k++)
            {
                writeFile << functionHeader[k] << "\n";
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq 0x56ff(%rip), %rsi      # 0x807e
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x21b0
movq 0x8871(%rip), %rcx      # 0xb208
movq 0x8862(%rip), %rax      # 0xb200
subq %rax, %rcx
cmpq $0x20, %rcx
je 0x2a68
xorl %r15d, %r15d
leaq -0x228(%rbp), %rbx
leaq 0x567a(%rip), %r14      # 0x8036
movq %r15, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x21d0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
testq %r15, %r15
jne 0x2a44
movq 0x8828(%rip), %rax      # 0xb218
cmpq %rax, 0x8829(%rip)      # 0xb220
je 0x2a44
movl $0x8, %r12d
xorl %r13d, %r13d
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x21d0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
incq %r13
movq 0x87f3(%rip), %rcx      # 0xb220
movq 0x87e4(%rip), %rax      # 0xb218
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %r13, %rcx
ja 0x2a02
incq %r15
movq 0x87ba(%rip), %rcx      # 0xb208
movq 0x87ab(%rip), %rax      # 0xb200
subq %rax, %rcx
sarq $0x5, %rcx
decq %rcx
cmpq %r15, %rcx
ja 0x29bc
movq 0x8569(%rip), %rax      # 0xafd8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x2130
leaq -0x130(%rbp), %rdi
callq 0x2090
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ab2
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: fxEval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> fxEval(std::string st)
{
    std::vector<std::string> store;
    std::string newgetData = "";
    for (int i = 0; i < st.length(); i++)
    {
        if (st[i] == '+' || st[i] == '-' || st[i] == '*' || st[i] == '/' || st[i] == '%' || st[i] == '^')
        {
            newgetData += ' ';
            newgetData += st[i];
            newgetData += ' ';
        }
        else
        {
            newgetData += st[i];
        }
    }
    newgetData += ' ';
    std::string helper_st = "";
    for (int i = 0; i < newgetData.length(); i++)
    {
        if (newgetData[i] != ' ')
        {
            helper_st += newgetData[i];
        }
        else
        {
            store.push_back(helper_st);
            helper_st = "";
        }
    }
    return store;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x55a6(%rip), %rdx      # 0x80a4
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0x7828
cmpq $0x0, 0x8(%r14)
je 0x2b6d
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
movabsq $0x200000000000561, %r12 # imm = 0x200000000000561
movq (%r14), %rax
movzbl (%rax,%r13), %ebx
movl %ebx, %eax
addl $-0x25, %eax
cmpl $0x39, %eax
ja 0x2b59
btq %rax, %r12
jae 0x2b59
movq %r15, %rdi
movl $0x20, %esi
callq 0x2140
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movb $0x20, %bl
movq %r15, %rdi
callq 0x2140
movsbl %bl, %esi
movq %r15, %rdi
callq 0x2140
incq %r13
cmpq %r13, 0x8(%r14)
ja 0x2b22
leaq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x2140
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x551a(%rip), %rdx      # 0x80a4
leaq -0x70(%rbp), %rdi
movq %rdx, %rsi
callq 0x7828
cmpq $0x0, -0x48(%rbp)
je 0x2bed
xorl %r12d, %r12d
leaq -0x70(%rbp), %r14
leaq 0x54f9(%rip), %r15      # 0x80a4
movq -0x50(%rbp), %rax
movb (%rax,%r12), %al
cmpb $0x20, %al
jne 0x2bd9
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x708a
movq -0x68(%rbp), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x2240
jmp 0x2be4
movsbl %al, %esi
movq %r14, %rdi
callq 0x2140
incq %r12
cmpq %r12, -0x48(%rbp)
ja 0x2bab
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2c02
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2c1b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c51
jmp 0x2c51
movq %rax, %r14
jmp 0x2c6d
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2c54
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2180
jmp 0x2c54
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2c6d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x30(%rbp), %rdi
callq 0x6aee
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
decq %rcx
xorl %edx, %edx
movb (%rax,%rdx), %dil
cmpb $0x20, %dil
je 0x4067
cmpb $0x20, (%rax,%rcx)
jne 0x4084
xorl %r8d, %r8d
cmpb $0x20, %dil
sete %r8b
addq %r8, %rdx
xorl %edi, %edi
cmpb $0x20, (%rax,%rcx)
sete %dil
subq %rdi, %rcx
jmp 0x4057
subq %rdx, %rcx
incq %rcx
movq %rbx, %rdi
callq 0x21a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x3fe6(%rip), %rdx      # 0x80a4
movq %rdx, %rsi
callq 0x7828
cmpq $0x0, 0x8(%r14)
je 0x4119
xorl %r12d, %r12d
movq (%r14), %rax
movzbl (%rax,%r12), %r13d
cmpl $0x3d, %r13d
je 0x40e4
cmpl $0x2c, %r13d
jne 0x4104
movq %rbx, %rdi
movl $0x20, %esi
callq 0x2140
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movb $0x20, %r13b
movq %rbx, %rdi
callq 0x2140
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x2140
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x40d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4141
movq (%r15), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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>::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void insert(const Key& key, const Value& value) {
		ScopedLock scoped(m_lock);
		typename MapType::iterator iter = m_cache.find(key);
		if (iter != m_cache.end()) {
			iter->second->value = value;
			m_keys.remove(iter->second);
			m_keys.push(iter->second);
		} else {
			Node<Key, Value>* n = new Node<Key, Value>(key, value);
			m_cache[key] = n;
			m_keys.push(n);
			prune();
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
movq %rdi, -0x30(%rbp)
callq *0x10(%rax)
leaq 0x10(%r14), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2e24
movq %rax, %rbx
leaq 0x18(%r14), %rax
cmpq %rax, %rbx
je 0x27d1
movq 0x40(%rbx), %rdi
addq $0x38, %rdi
movq %r15, %rsi
callq 0x2090
addq $0x40, %r14
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2bde
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2c30
jmp 0x280e
movl $0x58, %edi
callq 0x2120
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2c90
movq %r13, %rdi
movq %r12, %rsi
callq 0x2d16
movq %rbx, (%rax)
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x2c30
movq %r14, %rdi
callq 0x2d96
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rbx
movl $0x58, %esi
callq 0x2130
jmp 0x2840
jmp 0x2852
jmp 0x283d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2a77
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x4754(%rip), %rdi      # 0x6fd0
leaq 0x1838(%rip), %rsi      # 0x40bb
movl $0xd, %edx
callq 0x2150
movq 0x38(%r14), %rsi
movq 0x4738(%rip), %rdi      # 0x6fd0
callq 0x20b0
movq %rax, %r15
leaq 0x1822(%rip), %rsi      # 0x40c9
movl $0x6, %edx
movq %rax, %rdi
callq 0x2150
movq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x20b0
movq %rax, %r15
leaq 0x1806(%rip), %rsi      # 0x40d0
movl $0xf, %edx
movq %rax, %rdi
callq 0x2150
movq 0x68(%r14), %rsi
movq %r15, %rdi
callq 0x20b0
movq %rax, %r15
leaq 0x17f3(%rip), %rsi      # 0x40e0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x48(%r14), %r14
testq %r14, %r14
je 0x2938
movq %r14, %rdi
callq 0x35b6
movq 0x10(%r14), %r14
jmp 0x2925
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2964
jmp 0x2950
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2a77
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2e24
movq %rax, %r15
leaq 0x18(%r14), %rax
cmpq %rax, %r15
je 0x29dd
addq $0x40, %r14
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x2bde
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x2c30
movq 0x40(%r15), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x38, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x2080
leaq 0x43aa(%rip), %rcx      # 0x6d98
movq %rcx, (%rax)
leaq 0x4378(%rip), %rsi      # 0x6d70
movq 0x45e1(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x21a0
jmp 0x2a1d
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2a77
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>>>::~List()
void clear() {
		if (head) {
			delete head;
		}
		head = 0;
		tail = 0;
		size = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4246(%rip), %rax      # 0x6d20
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x2af0
movq (%rdi), %rax
callq *0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rax
cmpq %rsi, 0x8(%rdi)
jne 0x2bf3
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rdi)
cmpq %rax, 0x10(%rdi)
jne 0x2c01
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x2c12
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
leaq 0x8(%rax), %rdx
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x2c23
movq %rcx, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
decq 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x2c45
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
leaq 0x8(%rsi), %rcx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x2c56
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c78
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x2c7e
movq %rsi, 0x10(%rcx)
movq %rcx, 0x8(%rsi)
jmp 0x2c86
movq %rsi, 0x8(%rdi)
jmp 0x2c86
movq %rsi, 0x10(%rax)
movq %rax, 0x8(%rsi)
movq %rsi, 0x10(%rdi)
incq 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x2e0f
movq %rdi, %rbx
addq 0x68(%rdi), %rax
cmpq %rax, 0x38(%rdi)
jb 0x2e0f
movq 0x38(%rbx), %rax
cmpq 0x60(%rbx), %rax
jbe 0x2e0f
leaq 0x10(%rbx), %r15
leaq 0x40(%rbx), %r12
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x330e
movq %rax, %r13
leaq 0x18(%rax), %rsi
movq %r15, %rdi
callq 0x335e
movq %r15, %rdi
movq %rax, %rsi
callq 0x3410
testq %r13, %r13
je 0x2e00
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
incq %r14
movq 0x38(%rbx), %rax
cmpq 0x60(%rbx), %rax
ja 0x2dcf
jmp 0x2e12
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x335b
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x332c
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rax), %rdx
addq $0x8, %rax
testq %rdx, %rdx
je 0x333d
movq %rcx, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x8(%rdi), %rax
movq %rcx, 0x8(%rdi)
decq 0x18(%rdi)
jne 0x3359
movq $0x0, 0x10(%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6624(%rip), %rsi      # 0xa034
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3610
cmpq 0x8(%r14), %rax
jae 0x3a42
leaq 0x6609(%rip), %rcx      # 0xa035
movl $0x2, %edx
movl $0x1, %r8d
movq %r14, %rdi
movq %rax, %rsi
callq 0x33b0
movq (%r14), %rcx
cmpb $0x7e, (%rcx)
jne 0x3ada
leaq 0x65e2(%rip), %rdi      # 0xa037
callq 0x3420
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x4900
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3370
leaq 0x38(%rsp), %r14
movq -0x10(%r14), %rcx
movq -0x8(%r14), %r8
movq 0x10(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x3aaa
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x3ac9
leaq 0x18(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x3ac4
movq 0x18(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x3b19
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3110
jmp 0x3b27
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
leaq 0x10(%r14), %rax
cmpq %rax, %rcx
je 0x3af6
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x3afc
movups (%rax), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
jmp 0x3b9a
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33b0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x3b46
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3b4c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3b9a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bc8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
jmp 0x3bc8
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3be3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x3480
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x400c
popq %rbx
retq
callq 0x36c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x6171(%rip), %rdi      # 0xa1b1
movl $0x4, %esi
callq 0x3590
movq %rax, %r14
movq %rax, %rdi
callq 0x3ff1
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c0
testq %rax, %rax
je 0x4086
movq %rbx, %rdi
callq 0x3650
movq %rax, %r14
movq %rbx, %rdi
callq 0x3400
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fc9(%rip), %rdi      # 0xa056
callq 0x924b
movl $0x1, %edi
callq 0x3280
callq 0x4011
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4035
movq %rax, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0x40df
movq %r14, %rdi
callq 0x3180
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b08
movq %r14, %rdi
callq 0x3400
jmp 0x40f1
leaq 0x62ad(%rip), %rdx      # 0xa393
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4b08
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4a20
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x39fc
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x414b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
cmpl $0x1, %ebx
je 0x41a3
testl %ebx, %ebx
jne 0x4177
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x3310
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
movb $0x1, %bl
cmpl $0x8000, %eax           # imm = 0x8000
je 0x4179
xorl %ebx, %ebx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4194
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x3310
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
movb $0x1, %bl
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4177
jmp 0x4179
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x41e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/Linkerist[P]xs/src/xs.cc
// Function: finish(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void
finish(string result, bool retval)
{
 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

 // only save if list was not filtered!
 if (!NeedleGiven)
  list_to_file();

 // is the result really a dir?
 if (!valid(result, PATH_IS_DIR)) {
  fprintf(stderr, "This is not a valid directory:\n%s\n", result.c_str());
  exit(-3);
 }

 string resfile = canonify_filename(string(DefaultResultfile));
 ofstream out(resfile.c_str());
 if (out) {
  out << result << endl;
  out.close();
 }

 if (!retval)
  exit(1);

 exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x32a0
callq 0x3600
callq 0x35f0
callq 0x33e0
cmpb $0x0, 0xa293(%rip)      # 0xe4b0
jne 0x4224
callq 0x5cd5
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4a20
movq %r15, %rdi
movl $0x1, %esi
callq 0x40fc
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x426b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
testb %bpl, %bpl
je 0x4305
movq 0xa0fd(%rip), %rsi      # 0xe378
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
callq 0x4900
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x39fc
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movl $0x10, %edx
callq 0x33a0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x42fa
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x60(%rsp), %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x31b0
leaq 0x60(%rsp), %rdi
callq 0x34b0
testb %bl, %bl
je 0x432a
xorl %edi, %edi
callq 0x3410
movq 0x9cbc(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x5d6e(%rip), %rsi      # 0xa087
xorl %eax, %eax
callq 0x34c0
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x3410
movl $0x1, %edi
callq 0x3410
movq %rax, %rbx
movq 0x9c7a(%rip), %rax      # 0xdfb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x68(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x60(%rsp,%rcx)
callq 0x32c0
leaq 0x158(%rsp), %rdi
callq 0x3130
jmp 0x436e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43ba
movq 0x50(%rsp), %rsi
jmp 0x43b2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43ba
movq 0x10(%rsp), %rsi
jmp 0x43b2
movq %rax, %rbx
jmp 0x43ba
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x43ba
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %edi, %ebx
callq 0x33e0
cmpl $0xb, %ebx
jne 0x4459
movq 0x9bd0(%rip), %rbx      # 0xdfc8
movq (%rbx), %rdi
leaq 0x5ca8(%rip), %rsi      # 0xa0aa
movl $0xb, %edx
xorl %eax, %eax
callq 0x34c0
movq (%rbx), %rcx
leaq 0x5cae(%rip), %rdi      # 0xa0c6
movl $0x1a, %esi
movl $0x1, %edx
callq 0x3690
movq (%rbx), %rcx
leaq 0x5cb0(%rip), %rdi      # 0xa0e1
movl $0x40, %esi
movl $0x1, %edx
callq 0x3690
movq (%rbx), %rcx
leaq 0x5cd8(%rip), %rdi      # 0xa122
movl $0x26, %esi
movl $0x1, %edx
callq 0x3690
movq 0x9b68(%rip), %rax      # 0xdfc8
movq (%rax), %rcx
leaq 0x5cdf(%rip), %rdi      # 0xa149
movl $0x7, %esi
movl $0x1, %edx
callq 0x3690
movl $0x1, %edi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x1, 0x9ff7(%rip)      # 0xe4e8
leaq 0x9f80(%rip), %rax      # 0xe478
leaq 0x9f81(%rip), %rcx      # 0xe480
leaq 0x9f92(%rip), %rdx      # 0xe498
cmoveq %rcx, %rdx
leaq 0x9f7f(%rip), %rcx      # 0xe490
movq (%rdx), %rdx
cmoveq %rax, %rcx
subq (%rcx), %rdx
shrq $0x6, %rdx
leaq 0xa046(%rip), %rax      # 0xe56c
movl (%rax), %ecx
notl %ecx
addl %edx, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x944c(%rip), %rax      # 0xe4e8
cmpl $0x1, (%rax)
jne 0x50cb
leaq 0x5108(%rip), %rsi      # 0xa1b0
movq %rbx, %rdi
callq 0x3490
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0x50f8
leaq 0x942d(%rip), %rcx      # 0xe4ec
cmpb $0x0, (%rcx)
jne 0x50f6
cmpb $0x2e, (%rbx)
jne 0x50f6
jmp 0x50f8
leaq 0x93de(%rip), %rax      # 0xe4b0
cmpb $0x1, (%rax)
jne 0x50f6
leaq 0x93ca(%rip), %rax      # 0xe4a8
movq (%rax), %rsi
testq %rsi, %rsi
je 0x50f6
movq %rbx, %rdi
callq 0x30b0
testq %rax, %rax
sete %al
jmp 0x50f8
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x855c(%rip), %r14      # 0xe4b4
leaq 0x8589(%rip), %rax      # 0xe4e8
leaq 0x852a(%rip), %rcx      # 0xe490
leaq 0x8(%rcx), %rdx
leaq 0x8507(%rip), %rsi      # 0xe478
cmpl $0x0, (%rax)
leaq 0x8(%rsi), %rax
cmoveq %rdx, %rax
movq (%rax), %r15
cmoveq %rcx, %rsi
subq (%rsi), %r15
shrq $0x6, %r15
decl %r15d
addl (%r14), %edi
jns 0x5fb3
testb %bl, %bl
je 0x6004
leaq 0x8550(%rip), %rax      # 0xe4ed
cmpb $0x0, (%rax)
jne 0x6004
callq 0x44ea
leaq 0x85ce(%rip), %rcx      # 0xe57c
movl %eax, (%rcx)
movl %r15d, %edi
cmpl %r15d, %edi
jle 0x5fd7
testb %bl, %bl
je 0x6004
leaq 0x852a(%rip), %rax      # 0xe4ed
cmpb $0x0, (%rax)
jne 0x6004
leaq 0x85ad(%rip), %rax      # 0xe57c
movl $0x0, (%rax)
xorl %edi, %edi
movl %edi, (%r14)
leaq 0x859b(%rip), %rax      # 0xe57c
movl (%rax), %ecx
movl %edi, %edx
subl %ecx, %edx
leaq 0x857e(%rip), %rsi      # 0xe56c
cmpl (%rsi), %edx
jl 0x5ff6
incl %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x6004
cmpl %ecx, %edi
jne 0x6004
decl %ecx
movl %ecx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x84d7(%rip), %rax      # 0xe4e8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x6027
testl %eax, %eax
jne 0x6042
movl %edi, %eax
leaq 0x846b(%rip), %rcx      # 0xe490
jmp 0x6030
movl %edi, %eax
leaq 0x8448(%rip), %rcx      # 0xe478
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x6, %rdx
cmpq %rax, %rdx
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x847d(%rip), %rax      # 0xe4e8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x60a8
testl %eax, %eax
jne 0x60d8
leaq 0x8413(%rip), %rcx      # 0xe490
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x60b8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x411d(%rip), %rsi      # 0xa1b1
leaq 0x4117(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b08
jmp 0x6140
leaq 0x83c9(%rip), %rcx      # 0xe478
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x6123
leaq 0x83f5(%rip), %rcx      # 0xe4b4
movslq (%rcx), %rcx
shlq $0x6, %rcx
leaq (%rax,%rcx), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x31e0
leaq 0x42b4(%rip), %rsi      # 0xa393
leaq 0x8(%rsp), %rdi
callq 0x30e0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x610b
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4a20
jmp 0x6140
leaq 0x409f(%rip), %rsi      # 0xa1b1
leaq 0x4099(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b08
jmp 0x6140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4080(%rip), %rsi      # 0xa1b1
leaq 0x407a(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b08
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6157
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x6168
jmp 0x6168
jmp 0x6168
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6182
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x6169(%rip), %rax      # 0xdfc0
movq (%rax), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x7e6f
movswl 0x4(%rdx), %eax
incl %eax
movl %eax, 0x66ef(%rip)      # 0xe564
testq %rdx, %rdx
je 0x7e80
movswl 0x6(%rdx), %ecx
incl %ecx
movl %ecx, 0x66da(%rip)      # 0xe560
decl %ecx
movl %ecx, 0x66da(%rip)      # 0xe568
movl $0x0, 0x66d8(%rip)      # 0xe570
leal -0x3(%rax), %ecx
movl %ecx, 0x66cb(%rip)      # 0xe56c
leal -0x2(%rax), %ecx
movl %ecx, 0x66ca(%rip)      # 0xe574
decl %eax
movl %eax, 0x66c6(%rip)      # 0xe578
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
callq 0x3510
callq 0x3460
callq 0x3100
callq 0x33d0
movq 0x60f1(%rip), %rbx      # 0xdfc0
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x3160
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x34d0
xorl %edi, %edi
callq 0x32a0
callq 0x7e50
movb $0x1, 0x6684(%rip)      # 0xe580
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
leaq 0x5bf8(%rip), %rbx      # 0xe4e8
cmpl $0x0, (%rbx)
je 0x8967
leaq 0x5bf3(%rip), %rax      # 0xe4ef
cmpb $0x1, (%rax)
jne 0x8923
leaq 0x5b88(%rip), %rax      # 0xe490
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x895b
callq 0x5cd5
callq 0x4b98
movl $0x0, (%rbx)
jmp 0x8959
leaq 0x5b86(%rip), %rax      # 0xe4b0
movb $0x0, (%rax)
leaq 0x5b74(%rip), %rax      # 0xe4a8
movq $0x0, (%rax)
callq 0x4b98
xorl %eax, %eax
movl %eax, 0x5c34(%rip)      # 0xe57c
movl %eax, 0x5c36(%rip)      # 0xe584
leaq 0x5b5f(%rip), %rcx      # 0xe4b4
movl %eax, (%rcx)
movl %eax, (%rbx)
popq %rbx
retq
leaq 0x24ec(%rip), %rdi      # 0xae4e
callq 0x924b
movl $0x1, (%rbx)
leaq 0x183d(%rip), %rdi      # 0xa1b1
popq %rbx
jmp 0x50fa
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x5396(%rip), %r12      # 0xe4b4
movslq (%r12), %rax
movl %edi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
addl %eax, %ebp
js 0x9160
leaq 0x535b(%rip), %r13      # 0xe490
movq (%r13), %rsi
movq 0x8(%r13), %rcx
subq %rsi, %rcx
shrq $0x6, %rcx
cmpl %ecx, %ebp
jg 0x9160
leaq 0x5399(%rip), %rcx      # 0xe4e8
cmpl $0x0, (%rcx)
jne 0x9160
leaq 0x5355(%rip), %rcx      # 0xe4b0
cmpb $0x0, (%rcx)
je 0x9173
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movl %edi, %ebx
shlq $0x6, %rax
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x9a86
movl %ebp, %r14d
movq (%r13), %rax
shlq $0x6, %r14
leaq (%rax,%r14), %r15
movslq (%r12), %r12
shlq $0x6, %r12
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31e0
addq $0x20, %r15
addq $0x20, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31e0
addq (%r13), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x31e0
leaq 0x28(%rsp), %rsi
addq $0x20, %r14
movq %r14, %rdi
callq 0x31e0
movl %ebx, %edi
movl $0x1, %esi
callq 0x5f4a
callq 0x92c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x920c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9227
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x689e
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x5327(%rip)      # 0xe580
jne 0x92b1
movl 0x5317(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq 0x4d51(%rip), %r14      # 0xdfc0
movq (%r14), %rdi
callq 0x3390
leaq 0x1678(%rip), %rdi      # 0xa8f6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3340
callq 0x35f0
movq (%r14), %rdi
callq 0x3150
movl 0x52dd(%rip), %edi      # 0xe578
xorl %esi, %esi
callq 0x3250
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3570