LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::paintStats(_win_st*)
void Cryptogram::paintStats(WINDOW *w)
{
    // Print the statistics...
    char letters[26];
    int counts[26];
    int row, col;
    letterDistribution(letters, counts);
    wordDistribution_t words = wordDistribution();

    wclear(w);
    mvwprintw(w, 1, 0, 
              "Number of times each letter/word appears in cyphertext:");
    for (int i=0; i < 26; i++)
    {
        if (i < 13)
        {
            row = 3 + i;
            col = 1;
        } else {
            row = 3 + i - 13;
            col = 20;
        }
        wmove(w, row, col);
        wprintw(w, "%c %4d\n", letters[i], counts[i]);
    }
    int c = 0;
    for (wordDistribution_t::reverse_iterator t = words.rbegin();
         t != words.rend() && c < 13;
         t++, c++)
    {
        wmove(w, 3+c, 40);
        wprintw(w, "%3d %s", (*t).first, (*t).second.c_str());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x2a88
movq %rsp, %rdi
callq 0x2b24
movq %rbx, %rdi
callq 0x21c0
leaq 0x103a(%rip), %rcx      # 0x42a4
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
pushq $0x14
popq %r15
leaq 0x1056(%rip), %r14      # 0x42dc
xorl %r12d, %r12d
cmpq $0x1a, %r12
je 0x32cb
leal -0xa(%r12), %eax
leal 0x3(%r12), %esi
cmpq $0xd, %r12
cmovael %eax, %esi
movl %r15d, %edx
cmovbl %ebp, %edx
movq %rbx, %rdi
callq 0x21e0
movsbl 0x30(%rsp,%r12), %edx
movl 0x50(%rsp,%r12,4), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
incq %r12
jmp 0x3289
leaq 0x8(%rsp), %r15
pushq $0x28
popq %rbp
leaq 0x100a(%rip), %r14      # 0x42e4
xorl %r12d, %r12d
cmpq 0x18(%rsp), %r15
je 0x3328
cmpl $0xd, %r12d
jae 0x3328
addl $0x3, %r12d
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x21e0
movq %r15, %rdi
callq 0x21f0
movl 0x20(%rax), %edx
movq 0x28(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
movq %r15, %rdi
callq 0x21f0
movq %rax, %r15
addl $-0x2, %r12d
jmp 0x32dd
movq %rsp, %rdi
callq 0x339e
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3344
jmp 0x3344
movq %rax, %rbx
movq %rsp, %rdi
callq 0x339e
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/BrianEnigma[P]cryptoslam/src/cryptoslam.cpp
// Function: drawScreen(_win_st*, _win_st*, _win_st*, Cryptogram*)
void drawScreen(WINDOW *menu, 
                WINDOW *message, 
                WINDOW *alphabet, 
                Cryptogram *cr)
{
    // Print the menu...
    wclear(menu);
    wcolor_set(menu, 1, NULL);
    wattron(menu, WA_REVERSE);
    mvwprintw(menu, 0, 0, "%s", MENUBAR);
    wattroff(menu, WA_REVERSE);
    wmove(menu, 0, strlen(MENUBAR));

    // Print the alphabet...
    cr->paintAlphabet(alphabet);

    // Paint the message...
    cr->paintMessage(message);
    
    wrefresh(menu);
    wrefresh(message);
    wrefresh(alphabet);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x21c0
pushq $0x1
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x22a0
movq %r15, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x2100
leaq 0xcc0(%rip), %rcx       # 0x42e8
leaq 0xd59(%rip), %r8        # 0x4388
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
movq %r15, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x2270
pushq $0x3a
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x21e0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2fcc
movq %r12, %rdi
movq %r14, %rsi
callq 0x3104
movq %r15, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/BrianEnigma[P]cryptoslam/src/cryptoslam.cpp
// Function: mainLoop(Cryptogram*)
void mainLoop(Cryptogram *cr)
{
    WINDOW *main = initscr();
    WINDOW *menu = subwin(main, 1, COLS, 0, 0);
    WINDOW *message = subwin(main, LINES-4, COLS, 1, 0);
    WINDOW *alphabet = subwin(main, 3, COLS, LINES-3, 0);
    start_color();
    init_pair(1, COLOR_GREEN, COLOR_BLACK);
    init_pair(2, COLOR_BLUE, COLOR_BLACK);
    init_pair(3, COLOR_WHITE, COLOR_BLACK);
    char opt;
    while (1)
    {
        drawScreen(menu, message, alphabet, cr);
        wmove(main, 0, strlen(MENUBAR));
        wrefresh(main);
        noecho();
        opt = getch();
        echo();
        if ( (opt=='q') || (opt=='Q') )
            break;
        handleKey(opt, menu, message, alphabet, cr);
    }
    endwin();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22c0
movq %rax, %r14
movq 0x3228(%rip), %r13      # 0x6fc8
movl (%r13), %edx
pushq $0x1
popq %r12
movq %rax, %rdi
movl %r12d, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2340
movq %rax, %r15
movq 0x31fe(%rip), %rbp      # 0x6fc0
movl (%rbp), %esi
addl $-0x4, %esi
movl (%r13), %edx
movq %r14, %rdi
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2340
movq %rax, %r12
movl (%r13), %edx
movl (%rbp), %ecx
addl $-0x3, %ecx
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x2340
movq %rax, %r13
callq 0x2060
pushq $0x2
popq %rbp
pushq $0x1
popq %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2040
pushq $0x4
popq %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x2040
pushq $0x7
popq %rsi
pushq $0x3
popq %rdi
xorl %edx, %edx
callq 0x2040
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x35ec
movq %r14, %rdi
xorl %esi, %esi
pushq $0x3a
popq %rdx
callq 0x21e0
movq %r14, %rdi
callq 0x2200
callq 0x2210
movq 0x3189(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
callq 0x20c0
movl %eax, %ebp
callq 0x20a0
movl %ebp, %eax
andl $0xdf, %eax
cmpl $0x51, %eax
je 0x3e86
movsbl %bpl, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x3c18
jmp 0x3e25
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/BrianEnigma[P]cryptoslam/src/cryptoslam.cpp
// Function: main
int main(int argc, char *argv[])
{
    Cryptogram cr;
    if (argc==2)
        cr.loadFile(argv[1]);
    mainLoop(&cr);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
callq 0x246c
cmpl $0x2, %ebp
jne 0x3ebd
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x25d8
movq %rsp, %rdi
callq 0x3d83
movq %rsp, %rdi
callq 0x2516
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2516
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/base64.cpp
// Function: base64_enc[abi:cxx11](slice<unsigned char const>)
std::string base64_enc(slice<const unsigned char> data)
{
	std::string temp;
	temp.reserve((data.size()*4+2)/3);
	while (data) {
		auto chunk = data.size()>3 ? 3 : data.size();
		triple t = {{0}};
		for (unsigned k=0; k<chunk; ++k) t.octets[k] = data.shift();
		quad q = t.encode();
		chunk += 1; // n bytes => n+1 characters (for 1<=n<=3)
		for (unsigned k=0; k<chunk; ++k) temp += q.ascii[k];
	}
	return temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, 0x10(%rsp)
movb $0x0, 0x10(%rdi)
leaq 0x2(,%rdx,4), %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
callq 0x22b0
leaq 0x8(%rsp), %r15
testq %r14, %r14
je 0x2592
cmpq $0x3, %r14
pushq $0x3
popq %rax
cmovaeq %rax, %r14
movb $0x0, 0x2(%rsp)
andw $0x0, (%rsp)
xorl %r12d, %r12d
cmpl %r14d, %r12d
jae 0x24f0
movq %r15, %rdi
callq 0x27ce
movb (%rax), %al
movb %al, (%rsp,%r12)
incq %r12
jmp 0x24d8
movzbl (%rsp), %edi
movl %edi, %eax
shll $0x10, %eax
movzbl 0x1(%rsp), %r13d
shll $0x8, %r13d
movzbl 0x2(%rsp), %r12d
leal (%r12,%r13), %ebp
orl %eax, %r13d
shrl $0x2, %edi
callq 0x26ef
movb %al, 0x3(%rsp)
shrl $0xc, %r13d
andl $0x3f, %r13d
movl %r13d, %edi
callq 0x26ef
movl %eax, %r13d
shrl $0x6, %ebp
andl $0x3f, %ebp
movl %ebp, %edi
callq 0x26ef
movl %eax, %ebp
andl $0x3f, %r12d
movl %r12d, %edi
callq 0x26ef
movzbl %al, %eax
shll $0x18, %eax
movzbl %bpl, %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl %r13b, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rsp), %ecx
orl %eax, %ecx
movl %ecx, 0x4(%rsp)
xorl %r12d, %r12d
cmpl %r14d, %r12d
ja 0x2588
movsbl 0x4(%rsp,%r12), %esi
movq %rbx, %rdi
callq 0x2170
incq %r12
jmp 0x2570
movq 0x10(%rsp), %r14
jmp 0x24b7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25a8
jmp 0x25a8
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/base64.cpp
// Function: base64_dec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<unsigned char> base64_dec(std::string const& text)
{
	std::vector<unsigned char> temp;
	temp.reserve(text.size()*3/4);
	for (std::size_t pos=0; pos+2<=text.size(); pos+=4) {
		quad q = {{'A', 'A', 'A', 'A'}};
		auto remain = text.size() - pos;
		auto csize = remain>4 ? 4 : remain;
		for (unsigned k=0; k<csize; ++k) q.ascii[k] = text[pos+k];
		triple t = q.decode();
		csize -= 1; // n+1 characters => n bytes (for 1<=n<=3)
		for (unsigned k=0; k<csize; ++k) temp.push_back(t.octets[k]);
	}
	return temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
imulq $0x3, 0x8(%rsi), %rsi
shrq $0x2, %rsi
callq 0x2838
xorl %ecx, %ecx
movq %rcx, %rax
orq $0x2, %rax
movq 0x8(%r13), %r14
cmpq %r14, %rax
ja 0x26c6
subq %rcx, %r14
cmpq $0x4, %r14
pushq $0x4
popq %rax
cmovaeq %rax, %r14
movl $0x41414141, 0x8(%rsp)  # imm = 0x41414141
movq (%r13), %rax
movq %rcx, 0x10(%rsp)
addq %rcx, %rax
xorl %ecx, %ecx
cmpl %r14d, %ecx
jae 0x2633
movb (%rax,%rcx), %dl
movb %dl, 0x8(%rsp,%rcx)
incq %rcx
jmp 0x2622
movsbl 0x8(%rsp), %edi
callq 0x2744
movl %eax, %ebp
movsbl 0x9(%rsp), %edi
callq 0x2744
movl %eax, %r15d
movsbl 0xa(%rsp), %edi
callq 0x2744
movl %eax, %r12d
movsbl 0xb(%rsp), %edi
callq 0x2744
shll $0x12, %ebp
shll $0xc, %r15d
orl %r15d, %ebp
shll $0x6, %r12d
orl %r12d, %r15d
orl %r12d, %eax
movl %eax, %ecx
shll $0x10, %ecx
andl $0xff00, %r15d          # imm = 0xFF00
orl %ecx, %r15d
shrl $0x10, %ebp
orl %r15d, %ebp
movb %al, 0xe(%rsp)
movw %bp, 0xc(%rsp)
decq %r14
xorl %r15d, %r15d
movl %r15d, %r15d
cmpq %r15, %r14
jbe 0x26b8
leaq (%rsp,%r15), %rsi
addq $0xc, %rsi
movq %rbx, %rdi
callq 0x28c2
incl %r15d
jmp 0x269b
movq 0x10(%rsp), %rcx
addq $0x4, %rcx
jmp 0x25ea
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26dc
jmp 0x26dc
movq %rax, %r14
movq %rbx, %rdi
callq 0x28e8
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::num_to_char(unsigned int)
inline char num_to_char(std::uint32_t num)
{
	if (num < 52) {
		if (num < 26) return char('A' + num);
		return char('a' + (num - 26));
	} else {
		if (num < 62) return char('0' + (num - 52));
		if (num < 64) return "+/"[num - 62];
		assert(!"Illegal Base64 character index");
		throw std::domain_error("Illegal Base64 character index");
	}
}

// Assembly:
cmpl $0x33, %edi
ja 0x26ff
cmpl $0x19, %edi
ja 0x270a
addb $0x41, %dil
jmp 0x2723
cmpl $0x3d, %edi
ja 0x2710
addb $-0x4, %dil
jmp 0x2723
addb $0x47, %dil
jmp 0x2723
cmpl $0x3f, %edi
ja 0x2726
addl $-0x3e, %edi
leaq 0x28e5(%rip), %rax      # 0x5004
movb (%rdi,%rax), %dil
movl %edi, %eax
retq
pushq %rax
leaq 0x28d9(%rip), %rdi      # 0x5007
leaq 0x28f4(%rip), %rsi      # 0x5029
leaq 0x28f8(%rip), %rcx      # 0x5034
pushq $0x27
popq %rdx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::char_to_num(char)
inline std::uint32_t char_to_num(char c)
{
	if ('A' <= c && c <= 'Z') return c - 'A';
	if ('a' <= c && c <= 'z') return (c - 'a') + 26;
	if ('0' <= c && c <= '9') return (c - '0') + 52;
	if (c == '+') return 62;
	if (c == '/') return 63;
	throw std::domain_error("Illegal Base64 character found");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leal -0x41(%rdi), %eax
cmpb $0x19, %al
ja 0x2754
addl $-0x41, %edi
jmp 0x2781
leal -0x61(%rdi), %eax
cmpb $0x19, %al
ja 0x2760
addl $-0x47, %edi
jmp 0x2781
leal -0x30(%rdi), %eax
cmpb $0x9, %al
ja 0x276c
addl $0x4, %edi
jmp 0x2781
movsbl %dil, %eax
cmpl $0x2b, %eax
je 0x277e
cmpl $0x2f, %eax
jne 0x278b
pushq $0x3f
jmp 0x2780
pushq $0x3e
popq %rdi
movl %edi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x28ce(%rip), %rsi      # 0x506b
movq %rax, %rdi
callq 0x2110
movq 0x57e4(%rip), %rsi      # 0x7f90
movq 0x57ed(%rip), %rdx      # 0x7fa0
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/crc24.cpp
// Function: crc24hasher::process_block(slice<unsigned char const>)
void crc24hasher::process_block(slice<const unsigned char> data)
{
	if (!data) return;
	auto& tab = get_table();
	auto temp = this->state;
	do {
		unsigned bite = data.shift();
		temp = process_byte_impl(temp, bite, tab);
	} while (data);
	this->state = temp & 0xFFFFFF;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0x2b3e
movq %rdi, %rbx
callq 0x2a79
movl (%rbx), %ebp
leaq 0x8(%rsp), %r14
leaq 0x56b7(%rip), %r15      # 0x81c8
movq %r14, %rdi
callq 0x27ce
movl %ebp, %ecx
shll $0x8, %ecx
shrl $0x10, %ebp
xorb (%rax), %bpl
movzbl %bpl, %eax
movl %ecx, %ebp
xorl (%r15,%rax,4), %ebp
cmpq $0x0, 0x10(%rsp)
jne 0x2b11
andl $0xffffff, %ebp         # imm = 0xFFFFFF
movl %ebp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/gf256.cpp
// Function: operator*(gf256, gf256)
gf256 operator*(gf256 a, gf256 b)
{
	unsigned raw_a = a.to_byte();
	unsigned raw_b = b.to_byte();
	if (raw_a == 0 || raw_b == 0) {
		return gf256::zero();
	} else {
		auto& t = get_tables();
		return gf256(t.exp[(t.log[raw_a] + t.log[raw_b]) % 255]);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
testb %bpl, %bpl
sete %al
testb %bl, %bl
sete %cl
orb %al, %cl
je 0x2c65
xorl %eax, %eax
jmp 0x2c95
callq 0x2b73
movzbl %bpl, %eax
leaq 0x595b(%rip), %rcx      # 0x85d0
movzbl (%rax,%rcx), %edx
movzbl %bl, %eax
movzbl (%rax,%rcx), %eax
addl %edx, %eax
movw $0xff, %si
xorl %edx, %edx
divw %si
movzwl %dx, %eax
movb 0x100(%rax,%rcx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/gf256.cpp
// Function: operator/(gf256, gf256)
gf256 operator/(gf256 a, gf256 b)
{
	unsigned raw_a = a.to_byte();
	unsigned raw_b = b.to_byte();
	if (raw_a == 0) {
		return gf256::zero();
	} else if (raw_b == 0) {
		throw std::domain_error("division by zero");
	} else {
		auto& t = get_tables();
		return gf256(t.exp[(t.log[raw_a] + 255 - t.log[raw_b]) % 255]);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
testb %bpl, %bpl
je 0x2ce4
movl %esi, %ebx
testb %bl, %bl
je 0x2ceb
callq 0x2b73
movzbl %bpl, %eax
leaq 0x5913(%rip), %rcx      # 0x85d0
movzbl (%rax,%rcx), %eax
movzbl %bl, %edx
movzbl (%rdx,%rcx), %edx
subl %edx, %eax
addl $0xff, %eax
movw $0xff, %si
xorl %edx, %edx
divw %si
movzwl %dx, %eax
movb 0x100(%rax,%rcx), %al
jmp 0x2ce6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x23dd(%rip), %rsi      # 0x50da
movq %rax, %rdi
callq 0x2110
movq 0x5284(%rip), %rsi      # 0x7f90
movq 0x528d(%rip), %rdx      # 0x7fa0
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/poly.cpp
// Function: poly_evaluate(slice<unsigned char const>, unsigned char)
octet poly_evaluate(slice<const octet> polycoeffs, octet xcoord)
{
	auto const x = gf256(xcoord);
	auto acc = gf256::zero();
	auto fac = gf256::one();
	while (polycoeffs) {
		auto c = gf256(polycoeffs.shift());
		acc += c * fac;
		fac *= x;
	}
	return acc.to_byte();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
movq %rsi, 0x8(%rbx)
movb $0x1, %r15b
xorl %ebp, %ebp
movzbl %dl, %r14d
testq %rsi, %rsi
je 0x2d83
movq %rbx, %rdi
callq 0x27ce
movzbl (%rax), %edi
movzbl %r15b, %r15d
movl %r15d, %esi
callq 0x2c4b
xorb %al, %bpl
movl %r15d, %edi
movl %r14d, %esi
callq 0x2c4b
movl %eax, %r15d
movq 0x10(%rsp), %rsi
jmp 0x2d4f
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/poly.cpp
// Function: poly_interpolate(slice<point const>, unsigned char)
octet poly_interpolate(slice<const point> points, octet xcoord)
{
	// Lagrange interpolation
	const unsigned ord = points.size();
	const auto x = gf256(xcoord);
	auto acc = gf256::zero();
	for (unsigned i=0; i<ord; ++i) {
		auto prod = gf256::one();
		auto& pi = points[i];
		for (unsigned j=0; j<ord; ++j) {
			if (i != j) {
				auto& pj = points[j];
				prod *= (x - gf256(pj.x)) / (gf256(pi.x) - gf256(pj.x));
			}
		}
		acc += prod * gf256(pi.y);
	}
	return acc.to_byte();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movl %esi, %r14d
xorl %r15d, %r15d
xorl %eax, %eax
cmpq %r14, %r15
je 0x2e2c
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2e3c
movq %rax, %r13
movb $0x1, %al
xorl %ebp, %ebp
movzbl %al, %r12d
cmpq %rbp, %r14
je 0x2e11
cmpq %rbp, %r15
je 0x2e0c
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x2e3c
movb (%rax), %al
movl %eax, %ecx
xorb %bl, %cl
xorb (%r13), %al
movzbl %cl, %edi
movzbl %al, %esi
callq 0x2c9c
movzbl %al, %esi
movl %r12d, %edi
callq 0x2c4b
incq %rbp
jmp 0x2dd1
movzbl 0x1(%r13), %esi
movl %r12d, %edi
callq 0x2c4b
movq (%rsp), %rcx
xorb %al, %cl
movq %rcx, %rax
incq %r15
jmp 0x2db4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/./os_specific/nix/getrandom.cpp
// Function: get_random(slice<unsigned char>)
void get_random(slice<unsigned char> fill)
{
	ifstream& is = get_urandom();
	if (!is) throw runtime_error("Could not open " DEVICE);
	if (!is.read(reinterpret_cast<char*>(fill.begin()), fill.size()))
		throw runtime_error("Could not read from " DEVICE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x5b64(%rip), %al       # 0x89e0
testb %al, %al
je 0x2ec1
leaq 0x5951(%rip), %rax      # 0x87d8
movq 0x594a(%rip), %rcx      # 0x87d8
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0x2f12
leaq 0x5938(%rip), %rdi      # 0x87d8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2f2e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5b18(%rip), %rdi      # 0x89e0
callq 0x2320
testl %eax, %eax
je 0x2e80
leaq 0x5900(%rip), %rdi      # 0x87d8
leaq 0x229b(%rip), %rsi      # 0x517a
pushq $0xc
popq %rdx
callq 0x2330
movq 0x5092(%rip), %rdi      # 0x7f80
leaq 0x58e3(%rip), %rsi      # 0x87d8
leaq 0x52ac(%rip), %rdx      # 0x81a8
callq 0x2180
leaq 0x5ad8(%rip), %rdi      # 0x89e0
callq 0x2120
jmp 0x2e80
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2226(%rip), %rsi      # 0x514a
movq %rax, %rdi
callq 0x2060
jmp 0x2f48
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2226(%rip), %rsi      # 0x5166
movq %rax, %rdi
callq 0x2060
movq 0x50a1(%rip), %rsi      # 0x7ff0
movq 0x5052(%rip), %rdx      # 0x7fa8
movq %r14, %rdi
callq 0x2300
movq %rax, %rbx
leaq 0x5a78(%rip), %rdi      # 0x89e0
callq 0x2100
jmp 0x2f7c
jmp 0x2f71
movq %rax, %rbx
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::compute_crc24(unsigned int, unsigned int, slice<unsigned char const>)
uint32_t compute_crc24(unsigned k, unsigned n, slice<const octet> const data)
{
	crc24hasher h;
	h.process_byte(k);
	h.process_byte(n);
	h.process_block(data);
	return h.finish();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0x2a38
movl $0xff, %r13d
andl %r13d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x2a40
andl %r13d, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x2a40
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ae2
movq %r12, %rdi
callq 0x2b4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::~directory()
virt::fs::directory::~directory(){
	for (std::map<std::string, virt::fs::directory*>::iterator it = subdir.begin();
			it != subdir.end(); it++)
		if ((*it).first != "." && (*it).first != ".." && (*it).first != "")
			delete (*it).second;
	for (std::map<std::string, virt::fs::file*>::iterator it = files.begin();
			it != files.end(); it++)
		delete (*it).second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r12
leaq 0x30(%rdi), %r13
leaq 0x58f2(%rip), %r14      # 0x9005
leaq 0x58ea(%rip), %r15      # 0x9004
cmpq %r13, %r12
je 0x3781
leaq 0x20(%r12), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3f0a
testb %al, %al
je 0x3774
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3f0a
testb %al, %al
je 0x3774
movq %rbp, %rdi
leaq 0x6681(%rip), %rsi      # 0x9dcd
callq 0x3f0a
testb %al, %al
je 0x3774
movq 0x40(%r12), %rbp
testq %rbp, %rbp
je 0x3767
movq %rbp, %rdi
callq 0x36f6
movl $0x88, %esi
movq %rbp, %rdi
callq 0x31c0
movq %r12, %rdi
callq 0x3120
movq %rax, %r12
jmp 0x371a
movq 0x70(%rbx), %r15
leaq 0x60(%rbx), %r13
pushq $0x48
popq %r14
cmpq %r13, %r15
je 0x37bb
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x37a3
movq %r12, %rdi
callq 0x3f20
movq %r12, %rdi
movq %r14, %rsi
callq 0x31c0
movq %r15, %rdi
callq 0x3120
movq %rax, %r15
jmp 0x378d
leaq 0x58(%rbx), %rdi
leaq 0x28(%rbx), %r14
callq 0x40fc
movq %r14, %rdi
callq 0x4160
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30d0
movq %rax, %rdi
callq 0x3f14
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::path[abi:cxx11]()
std::string virt::fs::directory::path(){
	std::stack<std::string> mark;
	virt::fs::directory* it = this;
	while (it->parent != NULL && it->parent != it){
		mark.push(it->name);
		it = it->parent;
	}
	std::string full_path("");
	while (!mark.empty()){
		full_path = full_path + mark.top() + "/";
		mark.pop();
	}
	return "/" + full_path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3f3a
movq (%r14), %rax
testq %rax, %rax
je 0x3834
cmpq %r14, %rax
je 0x3834
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x4948
movq (%r14), %r14
jmp 0x3816
movq %rbx, (%rsp)
leaq 0x658e(%rip), %rsi      # 0x9dcd
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x3e68
movl $0x200, %ebx            # imm = 0x200
leaq 0x78(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x57a0(%rip), %r12      # 0x9007
leaq 0x98(%rsp), %r13
leaq 0x28(%rsp), %rbp
movq 0x58(%rsp), %rdx
cmpq 0x38(%rsp), %rdx
je 0x38d5
cmpq 0x60(%rsp), %rdx
jne 0x3893
movq 0x70(%rsp), %rax
movq -0x8(%rax), %rdx
addq %rbx, %rdx
addq $-0x20, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f74
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3f55
movq %r15, %rdi
movq %r13, %rsi
callq 0x3210
movq %r13, %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x30d0
movq %rbp, %rdi
callq 0x4bbe
jmp 0x3874
leaq 0x572b(%rip), %rsi      # 0x9007
leaq 0x8(%rsp), %rdx
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3fac
leaq 0x8(%rsp), %rdi
callq 0x30d0
leaq 0x28(%rsp), %rdi
callq 0x41c4
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x391a
jmp 0x3938
movq %rax, %rbx
jmp 0x392c
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x30d0
leaq 0x8(%rsp), %rdi
callq 0x30d0
jmp 0x393b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41c4
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::add_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool virt::fs::directory::add_subdir(std::string dirname, bool forced){
	if (!forced)
		if (subdir.find(dirname) != subdir.end())
			return false; 

	if (files.find(dirname) != files.end())
		return false;

	virt::fs::directory* new_subdir = new virt::fs::directory(this, dirname);
	this->remove_subdir(dirname);
	this->subdir[dirname] = new_subdir;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jne 0x39b4
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x4c1e
leaq 0x30(%r14), %rcx
cmpq %rcx, %rax
jne 0x39c9
leaq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x4d98
leaq 0x60(%r14), %rcx
cmpq %rcx, %rax
je 0x39cd
xorl %eax, %eax
jmp 0x3a3a
movl $0x88, %edi
callq 0x31b0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3240
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x35bc
leaq 0x8(%rsp), %rdi
callq 0x30d0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a7c
leaq 0x28(%rsp), %rdi
callq 0x30d0
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4022
movq %r15, (%rax)
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x3a74
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30d0
jmp 0x3a67
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::remove_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::fs::directory::remove_subdir(std::string dirname){
	std::map<std::string, virt::fs::directory*>::iterator it = subdir.find(dirname);
	if (it == subdir.end())
		return false;
	
	delete (*it).second;
	subdir.erase(dirname);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq %r15, %rdi
callq 0x4c1e
movq %rax, %r12
addq $0x30, %rbx
cmpq %rbx, %rax
je 0x3acd
movq 0x40(%r12), %r13
testq %r13, %r13
je 0x3ab5
movq %r13, %rdi
callq 0x36f6
movl $0x88, %esi
movq %r13, %rdi
callq 0x31c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e0e
cmpq %rbx, %r12
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::copy_content(virt::fs::directory*, virt::fs::directory*)
void virt::fs::copy_content(virt::fs::directory* source, virt::fs::directory* destination){
	
	for (std::map<std::string, virt::fs::file*>::iterator it = source->files.begin(); 
			it != source->files.end(); it++)
		destination->add_file(it->second->get_name(), it->second->content, true);

	for (std::map<std::string, virt::fs::directory*>::iterator it = source->subdir.begin();
			it != source->subdir.end(); it++){
		if (it->first == "" || it->first == "." || it->first == "..")
			continue;

		destination->add_subdir(it->second->get_name(), false);
		virt::fs::copy_content(it->second, destination->subdir[it->second->name]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x70(%rdi), %r13
leaq 0x60(%rdi), %rbp
leaq 0x48(%rsp), %rbx
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x3b52
movq 0x40(%r13), %rsi
movq %rbx, %rdi
callq 0x5610
movq 0x40(%r13), %rsi
addq $0x28, %rsi
movq %r12, %rdi
callq 0x3240
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
pushq $0x1
popq %rcx
callq 0x3c36
movq %r12, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
movq %r13, %rdi
callq 0x3120
movq %rax, %r13
jmp 0x3b03
movq 0x40(%r15), %r13
addq $0x30, %r15
leaq 0x28(%r14), %rax
movq %rax, (%rsp)
leaq 0x6264(%rip), %rbp      # 0x9dcd
leaq 0x28(%rsp), %rbx
cmpq %r15, %r13
je 0x3c02
leaq 0x20(%r13), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4088
testb %al, %al
jne 0x3bf2
movq %r12, %rdi
leaq 0x5471(%rip), %rsi      # 0x9005
callq 0x4088
testb %al, %al
jne 0x3bf2
movq %r12, %rdi
leaq 0x545d(%rip), %rsi      # 0x9004
callq 0x4088
testb %al, %al
jne 0x3bf2
movq 0x40(%r13), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x3240
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x398a
movq %rbx, %rdi
callq 0x30d0
movq 0x40(%r13), %r12
leaq 0x8(%r12), %rsi
movq (%rsp), %rdi
callq 0x4022
movq (%rax), %rsi
movq %r12, %rdi
callq 0x3add
movq %r13, %rdi
callq 0x3120
movq %rax, %r13
jmp 0x3b6e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c13
movq %rax, %r14
jmp 0x3c25
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::add_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool virt::fs::directory::add_file(std::string filename, std::string content, bool forced){
	if (!forced)
		if (this->files.find(filename) != this->files.end())
			return false;

	if (this->subdir.find(filename) != this->subdir.end())
		return false;

	virt::fs::file* temp = new virt::fs::file(this, filename);
	temp->content = content;
	this->remove_file(filename);
	this->files[filename] = temp;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
jne 0x3c63
leaq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x4d98
leaq 0x60(%r14), %rcx
cmpq %rcx, %rax
jne 0x3c78
leaq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x4c1e
leaq 0x30(%r14), %rcx
cmpq %rcx, %rax
je 0x3c7c
xorl %eax, %eax
jmp 0x3cf6
pushq $0x48
popq %rdi
callq 0x31b0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3240
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x556c
leaq 0x8(%rsp), %rdi
callq 0x30d0
movq %r15, %rdi
addq $0x28, %rdi
movq %r12, %rsi
callq 0x3100
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3e08
leaq 0x28(%rsp), %rdi
callq 0x30d0
addq $0x58, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4096
movq %r15, (%rax)
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x3d2e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30d0
jmp 0x3d23
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::move_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, virt::fs::directory*, virt::fs::directory*)
bool virt::fs::move_subdir(std::string dirname, virt::fs::directory* source, virt::fs::directory* destination){
	if (dirname == "" || dirname == "." || dirname == "..")
		return false;

	std::map<std::string, virt::fs::directory*>::iterator it = source->subdir.find(dirname);
	if (it == source->subdir.end())
		return false;

	virt::fs::directory* temp = (*it).second;

	destination->remove_subdir(dirname); 
	destination->subdir[dirname] = temp;

	source->subdir.erase(dirname);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x607a(%rip), %rsi      # 0x9dcd
callq 0x4088
testb %al, %al
jne 0x3de5
leaq 0x529e(%rip), %rsi      # 0x9005
movq %rbx, %rdi
callq 0x4088
testb %al, %al
jne 0x3de5
leaq 0x528a(%rip), %rsi      # 0x9004
movq %rbx, %rdi
callq 0x4088
testb %al, %al
jne 0x3de5
leaq 0x28(%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c1e
addq $0x30, %r12
cmpq %r12, %rax
je 0x3de5
movq 0x40(%rax), %r13
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a7c
movq %rsp, %rdi
callq 0x30d0
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4022
movq %r13, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e0e
movb $0x1, %al
jmp 0x3de7
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::remove_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::fs::directory::remove_file(std::string filename){
	std::map<std::string, virt::fs::file*>::iterator it = files.find(filename);
	if (it == files.end())
		return false;
	
	delete (*it).second;
	files.erase(filename);
	return true;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %r15
movq %r15, %rdi
callq 0x4d98
movq %rax, %r12
addq $0x60, %rbx
cmpq %rbx, %rax
je 0x3e57
movq 0x40(%r12), %r13
testq %r13, %r13
je 0x3e41
movq %r13, %rdi
callq 0x3f20
pushq $0x48
popq %rsi
movq %r13, %rdi
callq 0x31c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x5346
cmpq %rbx, %r12
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
virt::filesystem::dir_iterator virt::filesystem::directory(std::string absolute_path){
	std::stringstream ss(absolute_path);
	std::string token;

	virt::filesystem::dir_iterator iterator = this->root();	
	iterator.move_to(absolute_path);
	return iterator;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x3290
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r14, (%rsp)
movq %r14, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x3240
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x570a
leaq 0x10(%rsp), %rdi
callq 0x30d0
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x50(%rsp), %rdi
callq 0x3150
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x56ed
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x50(%rsp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::dir_iterator::move_to(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::filesystem::dir_iterator::move_to(std::string path){
	std::stringstream ss(path);
	std::string token;

	virt::filesystem::dir_iterator iterator = 
		(path[0] == '/')? (this->working_fs->root()) : (*this);
	

	while (std::getline(ss, token, '/')){
		if (token == "")
			continue;
		if (iterator.working_dir->has_child(token))
			iterator.working_dir = iterator.working_dir->child_dir(token);
		else 
			return false;
	}

	this->working_dir = iterator.working_dir;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x70(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x3290
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rax
xorl %ecx, %ecx
cmpb $0x2f, (%rax)
setne %cl
movq %r15, 0x8(%rsp)
movq (%r15,%rcx,8), %rbx
leaq 0x30(%rsp), %r15
pushq $0x2f
popq %rbp
leaq 0x4668(%rip), %r13      # 0x9dcd
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x32e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r12d
testb $0x5, %r12b
jne 0x57ef
movq %r15, %rdi
movq %r13, %rsi
callq 0x4088
testb %al, %al
jne 0x5765
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x3240
movq %rbx, (%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3960
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x30d0
testb %bl, %bl
je 0x57f8
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x3240
movq (%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, %rsi
callq 0x397a
movq %rax, %rbx
movq %r12, %rdi
callq 0x30d0
jmp 0x5765
movq 0x8(%rsp), %rax
movq %rbx, 0x8(%rax)
testb $0x5, %r12b
setne %bl
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x70(%rsp), %rdi
callq 0x3150
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x5839
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x5845
jmp 0x5842
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x70(%rsp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::dir_iterator::operator=(virt::filesystem::dir_iterator const&)
virt::filesystem::dir_iterator& virt::filesystem::dir_iterator::operator= 
		(const virt::filesystem::dir_iterator& c){
	if (this != &c){
		this->working_fs = c.working_fs;
		this->working_dir = c.working_dir;
	}
	return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x587e
movups (%rsi), %xmm0
movups %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::install_utility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, virt::os::utility*)
bool virt::operatingsystem::install_utility(std::string name, virt::os::utility* new_utility){
	if (utilities.find(name) != utilities.end())
		return false;

	utilities[name] = new_utility;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x5af2
movq %rax, %r15
leaq 0x8(%r12), %r13
cmpq %r13, %rax
jne 0x590e
movq %r12, %rdi
movq %r14, %rsi
callq 0x5a28
movq %rbx, (%rax)
cmpq %r13, %r15
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::remove_utility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::operatingsystem::remove_utility(std::string name){
	if (utilities.find(name) == utilities.end())
		return false;

	utilities.erase(name);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5af2
movq %rax, %r15
leaq 0x8(%r14), %r12
cmpq %r12, %rax
je 0x5948
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ed6
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::app(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
virt::os::utility* virt::operatingsystem::app(std::string name){
	std::map<std::string, virt::os::utility*>::iterator it = utilities.find(name);
	if (it == utilities.end()){
		return NULL;
	}

	return utilities[name];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5af2
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x5982
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5a28
movq (%rax), %rax
jmp 0x5984
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/shell.h
// Function: virt::util::shell::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			std::string command;

			std::cout << "[" << param << "]~> ";
			while (std::getline(std::cin, command)){
				if (command == "exit")
					break;

				std::size_t p = std::min(command.find(' '), command.length());	
				std::string appname = command.substr(0, p);
				command.erase(0, p+1);
				process_command(appname, command);
				std::cout << "[" << param << "]~> ";
			}
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x86fe(%rip), %rdi      # 0xffd0
leaq 0x1b79(%rip), %rsi      # 0x9452
callq 0x31a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3190
leaq 0x1b64(%rip), %rsi      # 0x9454
movq %rax, %rdi
callq 0x31a0
leaq 0x18(%rsp), %r13
leaq 0x38(%rsp), %rbx
leaq 0x78(%rsp), %rbp
leaq 0x58(%rsp), %r12
movq 0x86cd(%rip), %rdi      # 0xffe0
movq %r13, %rsi
callq 0x3060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x79f0
movq %r13, %rdi
leaq 0x2942(%rip), %rsi      # 0xa279
callq 0x4088
testb %al, %al
jne 0x79f0
movq %r13, %rdi
pushq $0x20
popq %rsi
xorl %edx, %edx
callq 0x3230
movq %rax, %r15
movq 0x20(%rsp), %rax
cmpq %r15, %rax
cmovbq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x31d0
incq %r15
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3070
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x3240
movq %r12, %rdi
movq %r13, %rsi
callq 0x3240
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x7a70
movq %r12, %rdi
callq 0x30d0
movq %rbp, %rdi
callq 0x30d0
movq 0x8613(%rip), %rdi      # 0xffd0
leaq 0x1a8e(%rip), %rsi      # 0x9452
callq 0x31a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
leaq 0x1a76(%rip), %rsi      # 0x9454
callq 0x31a0
movq %rbx, %rdi
callq 0x30d0
jmp 0x790c
leaq 0x23d6(%rip), %rsi      # 0x9dcd
leaq 0x38(%rsp), %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3e68
leaq 0x18(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a4c
jmp 0x7a4c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x30d0
jmp 0x7a3e
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x30d0
jmp 0x7a54
jmp 0x7a4c
movq %rax, %rbx
jmp 0x7a5e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x30d0
leaq 0x18(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/shell.h
// Function: virt::util::shell::process_command(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 process_command(std::string appname, std::string command){
			if (working_os->app(appname) == NULL)
				return ;
			std::string output = working_os->app(appname)->launch(command);
			std::cout << output;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r12
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x3240
movq %r12, %rdi
movq %r13, %rsi
callq 0x595a
movq %rax, %r12
leaq 0x40(%rsp), %rdi
callq 0x30d0
testq %r12, %r12
je 0x7b24
movq 0x8(%rbx), %r12
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3240
movq %r12, %rdi
movq %rbx, %rsi
callq 0x595a
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3240
movq (%r15), %rax
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r15, %rsi
callq *(%rax)
movq %rsp, %rdi
callq 0x30d0
leaq 0x60(%rsp), %rdi
callq 0x30d0
movq 0x84c3(%rip), %rdi      # 0xffd0
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x3190
leaq 0x20(%rsp), %rdi
callq 0x30d0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7b4e
movq %rax, %r14
movq %rsp, %rdi
callq 0x30d0
jmp 0x7b51
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x7b54
movq %rax, %r14
movq %rbx, %rdi
callq 0x30d0
movq %r14, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/cat.h
// Function: virt::util::cat::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!\n";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			if (param.find('/') != std::string::npos || param.find(' ') != std::string::npos)
				return "invalid characters '/' or ' ' in filename. See 'help cat' for more information.\n";

			std::map<std::string, virt::fs::file*>::iterator it = sh->shell_iterator.get_working_dir()->files.find(param);
			if (it == sh->shell_iterator.get_working_dir()->files.end())
				return "ERROR: No such file in current directory. For more help see 'help cat'.\n";
			return sh->shell_iterator.get_working_dir()->files[param]->content + "\n";
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x1671(%rip), %rsi      # 0x91ef
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x3e68
movq %r15, %rdi
movq %r12, %rsi
callq 0x595a
testq %rax, %rax
je 0x7bbd
leaq 0x7fe9(%rip), %rsi      # 0xfb90
leaq 0x7ff2(%rip), %rdx      # 0xfba0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x7bc0
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
callq 0x30d0
testq %r15, %r15
je 0x7c3b
pushq $0x1
popq %r12
movq (%r14), %rax
cmpb $0x20, (%rax)
jne 0x7bea
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3070
jmp 0x7bd3
pushq $0x1
popq %r12
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x7c0c
decq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3070
movq (%r14), %rax
jmp 0x7bee
pushq $0x2f
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3230
cmpq $-0x1, %rax
jne 0x7c32
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3230
cmpq $-0x1, %rax
je 0x7c5e
leaq 0x19c2(%rip), %rsi      # 0x95fb
jmp 0x7c42
leaq 0x1992(%rip), %rsi      # 0x95d4
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x50, %r15
movq %r15, %rdi
callq 0x586a
leaq 0x58(%rax), %rdi
movq %r14, %rsi
callq 0x4d98
movq %rax, %r12
movq %r15, %rdi
callq 0x586a
addq $0x60, %rax
cmpq %rax, %r12
je 0x7cb6
movq %r15, %rdi
callq 0x586a
leaq 0x58(%rax), %rdi
movq %r14, %rsi
callq 0x4096
movq (%rax), %rsi
addq $0x28, %rsi
leaq 0x2120(%rip), %rdx      # 0x9dcc
movq %rbx, %rdi
callq 0x7864
jmp 0x7c4f
leaq 0x198f(%rip), %rsi      # 0x964c
jmp 0x7c42
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x32c0