LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::paintMessage(_win_st*)
void Cryptogram::paintMessage(WINDOW *w)
{
    // 911:enigma THIS NEEDS WORK!
    int here=0, newHere=0, max;
    char *line;
    // Print the message, interlaced...
    wclear(w);
    wmove(w, 0, 0);
    // Find next \n
    wcolor_set(w, 3, NULL);
    max = cyphertext.length();
    // Traverse the string, one line at a time
    while (here != max)
    {
        // Print plaintext line
        line = strdup(plaintext.c_str() + here);
        for (char *c = line; *c; c++)
            if (*c == '\n') *c = 0;
        wattron(w, A_BOLD);
        wprintw(w, "%s\n", line);
        wattroff(w, A_BOLD);
        free(line);
        // Print cyphertext line
        line = strdup(cyphertext.c_str() + here);
        for (char *c = line; *c; c++)
            if (*c == '\n') *c = 0;
        wattron(w, A_DIM);
        wprintw(w, "%s\n", line);
        wattroff(w, A_DIM);
        free(line);
        // Move on to next line
        newHere = cyphertext.find('\n', here);
        // If no more newlines, ensure we are at the end
        if (newHere == -1)
            newHere = max;
        else
            here = newHere + 1;
        //else
        //    here = newHere;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2190
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x2260
movl 0x8(%r14), %ebp
testl %ebp, %ebp
je 0x346d
leaq 0x1f4d(%rip), %r15      # 0x52e0
xorl %r12d, %r12d
movslq %r12d, %r12
movq 0x20(%r14), %rdi
addq %r12, %rdi
callq 0x2300
movq %rax, %r13
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x33b6
testl %ecx, %ecx
jne 0x33b9
jmp 0x33be
movb $0x0, (%rax)
incq %rax
jmp 0x33a8
movq %rbx, %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x20e0
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x2240
movq %r13, %rdi
callq 0x2210
movq (%r14), %rdi
addq %r12, %rdi
callq 0x2300
movq %rax, %r13
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x3410
testl %ecx, %ecx
jne 0x3413
jmp 0x3418
movb $0x0, (%rax)
incq %rax
jmp 0x3402
movq %rbx, %rdi
movl $0x100000, %esi         # imm = 0x100000
xorl %edx, %edx
callq 0x20e0
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
movl $0x100000, %esi         # imm = 0x100000
xorl %edx, %edx
callq 0x2240
movq %r13, %rdi
callq 0x2210
movq %r14, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x2250
incl %eax
cmovnel %eax, %r12d
cmpl %ebp, %r12d
jne 0x3396
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bee
movq %rsp, %rdi
callq 0x2c8a
movq %rbx, %rdi
callq 0x2190
leaq 0x1e30(%rip), %rcx      # 0x52e4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
leaq 0x1e4b(%rip), %r14      # 0x531c
xorl %r15d, %r15d
leal -0xa(%r15), %eax
leal 0x3(%r15), %esi
cmpq $0xd, %r15
cmovael %eax, %esi
movl $0x14, %edx
cmovbl %ebp, %edx
movq %rbx, %rdi
callq 0x21b0
movsbl 0x30(%rsp,%r15), %edx
movl 0x50(%rsp,%r15,4), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
incq %r15
cmpq $0x1a, %r15
jne 0x34d4
leaq 0x8(%rsp), %r14
cmpq 0x10(%r14), %r14
je 0x3577
leaq 0x1dfe(%rip), %r15      # 0x5324
xorl %r12d, %r12d
leal 0x3(%r12), %esi
movq %rbx, %rdi
movl $0x28, %edx
callq 0x21b0
movq %r14, %rdi
callq 0x21c0
movl 0x20(%rax), %edx
movq 0x28(%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x21c0
cmpq 0x18(%rsp), %rax
je 0x3577
movq %rax, %r14
leal 0x1(%r12), %eax
cmpl $0xc, %r12d
movl %eax, %r12d
jb 0x3529
movq %rsp, %rdi
callq 0x35b2
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3593
jmp 0x3593
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35b2
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2190
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2260
movq %r15, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x20e0
leaq 0x1b12(%rip), %rcx      # 0x5328
leaq 0x1bab(%rip), %r8       # 0x53c8
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 0x2240
movq %r15, %rdi
xorl %esi, %esi
movl $0x3a, %edx
callq 0x21b0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3222
movq %r12, %rdi
movq %r14, %rsi
callq 0x334c
movq %r15, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2280
movq %rax, %r14
movq 0x4012(%rip), %r13      # 0x7fc8
movl (%r13), %edx
movq %rax, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2310
movq %rax, %r15
movq 0x3fea(%rip), %rbp      # 0x7fc0
movl (%rbp), %esi
addl $-0x4, %esi
movl (%r13), %edx
movq %r14, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2310
movq %rax, %r12
movl (%r13), %edx
movl (%rbp), %ecx
addl $-0x3, %ecx
movq %r14, %rdi
movl $0x3, %esi
xorl %r8d, %r8d
callq 0x2310
movq %rax, %r13
callq 0x2060
movl $0x1, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2040
movl $0x2, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x2040
movl $0x3, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2040
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x37d8
movq %r14, %rdi
xorl %esi, %esi
movl $0x3a, %edx
callq 0x21b0
movq %r14, %rdi
callq 0x21d0
callq 0x21e0
movq 0x3f64(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
callq 0x20b0
movl %eax, %ebp
callq 0x20a0
movl %ebp, %eax
andl $0xdf, %eax
cmpl $0x51, %eax
je 0x40ab
movsbl %bpl, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x3e24
jmp 0x4048
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
cmpl $0x2, %ebp
jne 0x40e2
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x262a
movq %rsp, %rdi
callq 0x3f99
movq %rsp, %rdi
callq 0x2530
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2530
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x2(,%rdx,4), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
movq %rdx, %rsi
callq 0x22d0
testq %r14, %r14
je 0x2708
movl $0x3, %r13d
leaq 0x18(%rsp), %r15
leaq 0x2a37(%rip), %rbp      # 0x5004
cmpq $0x3, %r14
cmovaeq %r13, %r14
movb $0x0, 0xa(%rsp)
movw $0x0, 0x8(%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x2a5c
movb (%rax), %al
movb %al, 0x8(%rsp,%r12)
incq %r12
cmpl %r14d, %r12d
jb 0x25e4
movzbl 0x8(%rsp), %ecx
movl %ecx, %eax
shrl $0x2, %eax
cmpl $0xcf, %ecx
ja 0x2616
cmpb $0x67, %cl
ja 0x261f
addb $0x41, %al
jmp 0x2629
cmpb $-0x9, %cl
ja 0x2623
addb $-0x4, %al
jmp 0x2629
addb $0x47, %al
jmp 0x2629
addl $-0x3e, %eax
movb (%rax,%rbp), %al
shll $0x10, %ecx
movzbl 0x9(%rsp), %edx
shll $0x8, %edx
orl %edx, %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
cmpl $0x33, %ecx
ja 0x264b
cmpl $0x19, %ecx
ja 0x2655
addb $0x41, %cl
jmp 0x2660
cmpl $0x3d, %ecx
ja 0x265a
addb $-0x4, %cl
jmp 0x2660
addb $0x47, %cl
jmp 0x2660
addl $-0x3e, %ecx
movb (%rcx,%rbp), %cl
movzbl 0xa(%rsp), %esi
orl %esi, %edx
shrl $0x6, %edx
andl $0x3f, %edx
cmpl $0x33, %edx
ja 0x267c
cmpl $0x19, %edx
ja 0x2686
addb $0x41, %dl
jmp 0x2691
cmpl $0x3d, %edx
ja 0x268b
addb $-0x4, %dl
jmp 0x2691
addb $0x47, %dl
jmp 0x2691
addl $-0x3e, %edx
movb (%rdx,%rbp), %dl
andl $0x3f, %esi
cmpl $0x33, %esi
ja 0x26a4
cmpl $0x19, %esi
ja 0x26af
addb $0x41, %sil
jmp 0x26bc
cmpl $0x3d, %esi
ja 0x26b5
addb $-0x4, %sil
jmp 0x26bc
addb $0x47, %sil
jmp 0x26bc
addl $-0x3e, %esi
movb (%rsi,%rbp), %sil
movzbl %sil, %esi
shll $0x18, %esi
movzbl %dl, %edx
shll $0x10, %edx
orl %esi, %edx
movzbl %cl, %ecx
shll $0x8, %ecx
orl %edx, %ecx
movzbl %al, %eax
orl %ecx, %eax
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
movsbl 0xc(%rsp,%r12), %esi
movq %rbx, %rdi
callq 0x2180
incq %r12
leal -0x1(%r12), %eax
cmpl %r14d, %eax
jb 0x26df
movq 0x20(%rsp), %r14
testq %r14, %r14
jne 0x25cd
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x271e
jmp 0x271e
movq %rax, %r14
movq (%rbx), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2739
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d00
movq %rdi, %rbx
callq 0x2c8d
movl (%rbx), %ebp
leaq 0x8(%rsp), %r14
leaq 0x5505(%rip), %r15      # 0x81d8
movq %r14, %rdi
callq 0x2a5c
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 0x2cd3
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_O3/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 0x2dda
xorl %eax, %eax
jmp 0x2e13
callq 0x2d40
movzbl %bpl, %eax
leaq 0x57f6(%rip), %rcx      # 0x85e0
movzbl (%rax,%rcx), %eax
movzbl %bl, %edx
movzbl (%rdx,%rcx), %edx
addl %eax, %edx
imull $0x203, %edx, %eax      # imm = 0x203
shrl $0x11, %eax
movl %eax, %esi
shll $0x8, %esi
subl %esi, %eax
addl %edx, %eax
movzwl %ax, %eax
movb 0x100(%rax,%rcx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e77
movl %esi, %ebx
testb %bl, %bl
je 0x2e7e
callq 0x2d40
movzbl %bpl, %eax
leaq 0x57a5(%rip), %rcx      # 0x85e0
movzbl (%rax,%rcx), %eax
movzbl %bl, %edx
movzbl (%rdx,%rcx), %edx
subl %edx, %eax
leal 0xff(%rax), %edx
movl $0xffff, %esi           # imm = 0xFFFF
andl %esi, %edx
imull $0x203, %edx, %edx      # imm = 0x203
shrl $0x11, %edx
movl %edx, %edi
shll $0x8, %edi
subl %edi, %edx
addl %edx, %eax
addl $0xff, %eax
andl %esi, %eax
movb 0x100(%rax,%rcx), %al
jmp 0x2e79
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x21e4(%rip), %rsi      # 0x5076
movq %rax, %rdi
callq 0x2100
movq 0x50df(%rip), %rsi      # 0x7f80
movq 0x50e8(%rip), %rdx      # 0x7f90
movq %rbx, %rdi
callq 0x2320
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x2f1a
movb $0x1, %r15b
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
movzbl %dl, %ebp
movq %r14, %rdi
callq 0x2a5c
movzbl (%rax), %edi
movzbl %r15b, %r15d
movl %r15d, %esi
callq 0x2dc0
xorb %al, %bl
movl %r15d, %edi
movl %ebp, %esi
callq 0x2dc0
movl %eax, %r15d
cmpq $0x0, 0x10(%rsp)
jne 0x2eea
jmp 0x2f1c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x59e4(%rip), %al       # 0x89f0
testb %al, %al
je 0x3051
leaq 0x57d1(%rip), %rax      # 0x87e8
movq 0x57ca(%rip), %rcx      # 0x87e8
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0x30a4
leaq 0x57b8(%rip), %rdi      # 0x87e8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x30c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5998(%rip), %rdi      # 0x89f0
callq 0x2340
testl %eax, %eax
je 0x3010
leaq 0x5780(%rip), %rdi      # 0x87e8
leaq 0x20a7(%rip), %rsi      # 0x5116
movl $0xc, %edx
callq 0x2350
movq 0x4ef0(%rip), %rdi      # 0x7f70
leaq 0x5761(%rip), %rsi      # 0x87e8
leaq 0x512a(%rip), %rdx      # 0x81b8
callq 0x2190
leaq 0x5956(%rip), %rdi      # 0x89f0
callq 0x2110
jmp 0x3010
movl $0x10, %edi
callq 0x20a0
movq %rax, %r14
leaq 0x202e(%rip), %rsi      # 0x50e6
movq %rax, %rdi
callq 0x2070
jmp 0x30de
movl $0x10, %edi
callq 0x20a0
movq %rax, %r14
leaq 0x202c(%rip), %rsi      # 0x5102
movq %rax, %rdi
callq 0x2070
movq 0x4f0b(%rip), %rsi      # 0x7ff0
movq 0x4eb4(%rip), %rdx      # 0x7fa0
movq %r14, %rdi
callq 0x2320
movq %rax, %rbx
leaq 0x58f2(%rip), %rdi      # 0x89f0
callq 0x20f0
jmp 0x3112
jmp 0x3107
movq %rax, %rbx
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c4c
movl $0xff, %r13d
andl %r13d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x2c54
andl %r13d, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x2c54
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ca4
movq %r12, %rdi
callq 0x2d0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
leaq 0x30(%rdi), %r13
cmpq %r13, %r14
je 0x382c
leaq 0x7843(%rip), %r15      # 0xb005
leaq 0x783b(%rip), %r12      # 0xb004
leaq 0x20(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3090
testl %eax, %eax
je 0x381c
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3090
testl %eax, %eax
je 0x381c
movq %rbp, %rdi
leaq 0x85d8(%rip), %rsi      # 0xbdcd
callq 0x3090
testl %eax, %eax
je 0x381c
movq 0x40(%r14), %rbp
testq %rbp, %rbp
je 0x380f
movq %rbp, %rdi
callq 0x37a0
movl $0x88, %esi
movq %rbp, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3130
movq %rax, %r14
cmpq %r13, %rax
jne 0x37c9
leaq 0x28(%rbx), %r14
leaq 0x58(%rbx), %r15
movq 0x70(%rbx), %r12
leaq 0x60(%rbx), %rbp
cmpq %rbp, %r12
je 0x3898
movq 0x40(%r12), %r13
testq %r13, %r13
je 0x387b
movq 0x28(%r13), %rdi
leaq 0x38(%r13), %rax
cmpq %rax, %rdi
je 0x3863
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
cmpq %rax, %rdi
je 0x387b
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movl $0x48, %esi
movq %r13, %rdi
callq 0x31c0
movq %r12, %rdi
callq 0x3130
movq %rax, %r12
cmpq %rbp, %rax
jne 0x3841
movq %r15, %rdi
callq 0x447c
movq %r14, %rdi
callq 0x44f4
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x38ce
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4b64
movq (%r14), %rax
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %al
orb %cl, %al
jne 0x394b
leaq 0x70(%rsp), %r15
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x4cdc
movq (%r14), %r14
movq (%r14), %rax
testq %rax, %rax
je 0x394b
cmpq %r14, %rax
jne 0x392f
movq %rbx, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x846d(%rip), %rdx      # 0xbdcd
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x4718
movq 0xa0(%rsp), %rdx
cmpq 0x80(%rsp), %rdx
je 0x3a78
leaq 0x40(%rsp), %rbx
leaq 0x50(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x766e(%rip), %r12      # 0xb007
leaq 0x30(%rsp), %r13
leaq 0x70(%rsp), %rbp
cmpq 0xa8(%rsp), %rdx
jne 0x39c1
movq 0xb8(%rsp), %rax
movq -0x8(%rax), %rdx
movl $0x200, %eax            # imm = 0x200
addq %rax, %rdx
addq $-0x20, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x42a1
movq %r14, %rdi
movq %r12, %rsi
callq 0x3300
movq %rbx, 0x30(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x39fe
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x3a04
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r13, %rsi
callq 0x3220
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a3e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x3a5a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbp, %rdi
callq 0x4f76
movq 0xa0(%rsp), %rdx
cmpq 0x80(%rsp), %rdx
jne 0x39a3
leaq 0x7588(%rip), %rsi      # 0xb007
leaq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x42fb
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3aad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x70(%rsp), %rdi
callq 0x456c
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ad5
jmp 0x3ad0
movq %rax, %r14
jmp 0x3b15
movq %rax, %r14
jmp 0x3af9
movq %rax, %r14
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x3af9
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b15
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x70(%rsp), %rdi
callq 0x456c
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x5002
movq %rax, %r15
addq $0x30, %rbx
cmpq %rbx, %rax
je 0x3d15
movq 0x40(%r15), %r13
testq %r13, %r13
je 0x3cf2
movq %r13, %rdi
callq 0x37a0
movl $0x88, %esi
movq %r13, %rdi
callq 0x31c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x51e6
movq %r14, %rdi
movq %rax, %rsi
callq 0x529a
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
jne 0x3f49
leaq 0x58(%r15), %rdi
movq %r14, %rsi
callq 0x515c
leaq 0x60(%r15), %rcx
cmpq %rcx, %rax
jne 0x3f5e
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x5002
leaq 0x30(%r15), %rcx
cmpq %rcx, %rax
je 0x3f65
xorl %eax, %eax
jmp 0x4016
movl $0x48, %edi
callq 0x31b0
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4ace
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58aa
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3fb1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
addq $0x28, %rdi
movq %r12, %rsi
callq 0x3100
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x4ace
movq %r15, %rdi
movq %r12, %rsi
callq 0x4186
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x4002
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x58, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4400
movq %rbx, (%rax)
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x4066
movq 0x30(%rsp), %rsi
incq %rsi
jmp 0x4061
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x4059
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x4059
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x7d41(%rip), %rsi      # 0xbdcd
callq 0x3090
testl %eax, %eax
je 0x4152
leaq 0x6f65(%rip), %rsi      # 0xb005
movq %rbx, %rdi
callq 0x3090
testl %eax, %eax
je 0x4152
leaq 0x6f4d(%rip), %rsi      # 0xb004
movq %rbx, %rdi
callq 0x3090
testl %eax, %eax
je 0x4152
leaq 0x28(%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5002
addq $0x30, %r12
cmpq %r12, %rax
je 0x4152
movq 0x40(%rax), %r13
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x4ace
movq %r14, %rdi
movq %r12, %rsi
callq 0x3cba
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4126
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4384
movq %r13, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x51e6
movq %r15, %rdi
movq %rax, %rsi
callq 0x529a
movb $0x1, %al
jmp 0x4154
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x417d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq %r14, %rdi
callq 0x515c
movq %rax, %r15
addq $0x60, %rbx
cmpq %rbx, %rax
je 0x4209
movq 0x40(%r15), %r13
testq %r13, %r13
je 0x41e6
movq 0x28(%r13), %rdi
leaq 0x38(%r13), %rax
cmpq %rax, %rdi
je 0x41ce
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
cmpq %rax, %rdi
je 0x41e6
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movl $0x48, %esi
movq %r13, %rdi
callq 0x31c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x5696
movq %r14, %rdi
movq %rax, %rsi
callq 0x574a
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rsp), %rdi
movl $0x18, %edx
callq 0x3290
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %r14, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x4ace
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5b30
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a87
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x5a9e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb513(%rip), %rsi      # 0x10fb8
leaq 0x58(%rsp), %rdi
callq 0x3160
leaq 0xd8(%rsp), %rdi
callq 0x30b0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x5af2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5af2
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b09
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb4a8(%rip), %rsi      # 0x10fb8
leaq 0x58(%rsp), %rdi
callq 0x3160
leaq 0xd8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x3290
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r15), %rax
xorl %ecx, %ecx
cmpb $0x2f, (%rax)
setne %cl
movq %rbx, 0x68(%rsp)
movq (%rbx,%rcx,8), %r15
movq %rsp, %r12
leaq 0x6242(%rip), %r13      # 0xbdcd
leaq 0x40(%rsp), %rbp
movq %r14, %rdi
movq %r12, %rsi
movl $0x2f, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebx
testb $0x5, %bl
jne 0x5c71
movq %r12, %rdi
movq %r13, %rsi
callq 0x3090
testl %eax, %eax
je 0x5b90
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4ace
movq %r15, 0x60(%rsp)
movq %r15, %rdi
movq %rbp, %r15
movq %rbp, %rsi
callq 0x3b4c
movl %eax, %ebp
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5c12
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
je 0x5c7a
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4ace
movq 0x60(%rsp), %rdi
movq %r15, %rbp
leaq 0x20(%rsp), %rsi
callq 0x3b66
movq %rax, %r15
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5b90
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5b90
movq 0x68(%rsp), %rax
movq %r15, 0x8(%rax)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c95
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
testb $0x5, %bl
setne %bl
movq 0xb316(%rip), %rsi      # 0x10fb8
leaq 0x70(%rsp), %rdi
callq 0x3160
leaq 0xf0(%rsp), %rdi
callq 0x30b0
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5d0c
movq 0x30(%rsp), %rsi
jmp 0x5cfd
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5d0c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5d0c
jmp 0x5d09
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5d27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb28a(%rip), %rsi      # 0x10fb8
leaq 0x70(%rsp), %rdi
callq 0x3160
leaq 0xf0(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d6a
movups (%rsi), %xmm0
movups %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6046
movq %rax, %r15
leaq 0x8(%r12), %r13
cmpq %r13, %rax
jne 0x5dfc
movq %r12, %rdi
movq %r14, %rsi
callq 0x5f52
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_O3/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, %r15
movq %rdi, %rbx
callq 0x6046
movq %rax, %r14
leaq 0x8(%rbx), %r12
cmpq %r12, %rax
je 0x5e41
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63e2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6496
cmpq %r12, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6046
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x5e7c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f52
movq (%rax), %rax
jmp 0x5e7e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x4ace
movq %r12, %rdi
movq %r13, %rsi
callq 0x5e54
movq %rax, %r12
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8f31
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r12, %r12
je 0x8ffb
movq 0x8(%r15), %r15
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x4ace
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e54
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4ace
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8fb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x8fca
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x7ff5(%rip), %rdi      # 0x10fd0
callq 0x3200
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ffb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq -0x10(%r12), %rdi
jmp 0x9054
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x904f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x904f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9065
movq 0x58(%rsp), %rsi
jmp 0x905d
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x9065
movq (%r12), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/FalconUA[P]vfs/./utility/cd.h
// Function: virt::util::cd::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);

			bool s = sh->shell_iterator.move_to(param);
			if (!s)
				return "No such directory. See 'help cd' for more information";
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1f6f(%rip), %rsi      # 0xb1ef
leaq 0x1f6d(%rip), %rdx      # 0xb1f4
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4718
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e54
testq %rax, %rax
je 0x92c1
leaq 0x78dd(%rip), %rsi      # 0x10b88
leaq 0x78e6(%rip), %rdx      # 0x10b98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x92c4
xorl %r15d, %r15d
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x92db
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r15, %r15
jne 0x9309
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22e6(%rip), %rsi      # 0xb5d4
leaq 0x2305(%rip), %rdx      # 0xb5fa
jmp 0x93ae
movl $0x1, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movq (%r14), %rsi
cmpb $0x20, (%rsi)
je 0x92fa
movq 0x8(%r14), %rdx
cmpb $0x20, -0x1(%rsi,%rdx)
jne 0x9344
decq %rdx
movq %rdx, %rax
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3070
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x1(%rdx), %rax
cmpb $0x20, -0x1(%rsi,%rdx)
je 0x9322
addq $0x50, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4ace
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b30
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9385
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testb %bpl, %bpl
je 0x93a0
leaq 0x2a35(%rip), %rdx      # 0xbdcd
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x93b1
leaq 0x2570(%rip), %rsi      # 0xb917
leaq 0x259e(%rip), %rdx      # 0xb94c
movq %rbx, %rdi
callq 0x4718
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x93da
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x93eb
movq (%r13), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/FalconUA[P]vfs/./utility/pwd.h
// Function: virt::util::pwd::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!";

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

			return sh->shell_iterator.get_working_dir()->path() + "\n";
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1910(%rip), %rsi      # 0xb1ef
leaq 0x190e(%rip), %rdx      # 0xb1f4
movq %rsp, %r12
movq %r12, %rdi
callq 0x4718
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e54
testq %rax, %rax
je 0x991e
leaq 0x7280(%rip), %rsi      # 0x10b88
leaq 0x7289(%rip), %rdx      # 0x10b98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x9921
xorl %r15d, %r15d
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9937
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r15, %r15
jne 0x996d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2224(%rip), %rsi      # 0xbb6e
leaq 0x2242(%rip), %rdx      # 0xbb93
movq %rbx, %rdi
callq 0x4718
jmp 0x9a27
movl $0x1, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movq (%r14), %rax
cmpb $0x20, (%rax)
je 0x995e
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x99a2
decq %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3070
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq -0x1(%rcx), %rsi
cmpb $0x20, -0x1(%rax,%rcx)
je 0x9983
addq $0x50, %r15
movq %r15, %rdi
callq 0x5d56
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x38de
leaq 0x2407(%rip), %rsi      # 0xbdcc
movq %r14, %rdi
callq 0x3300
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x99ef
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x99f5
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a27
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a69
movq 0x30(%rsp), %rsi
jmp 0x9a61
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9a69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop