LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::randomizeMessage()
void Cryptogram::randomizeMessage()
{
    string tempStr;
    bool matchKey;
    do{
        matchKey = false;
        randomizeKeys();
        for (int i=0; i<26; i++)
        {
            if (alphabet[i]==i+'A')
                matchKey = true;
        }
    }while(matchKey);
    calcPlaintext();
    cyphertext = plaintext;
    plaintext = string(" ", cyphertext.length());
    calcPlaintext();
    for (int i=0; i<26; i++)
        alphabet[i] = ' ';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x40(%rdi), %r13
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2976
movl $0x41, %ecx
xorl %eax, %eax
movsbq -0x1(%rbx,%rcx), %rdx
movl %edx, %edx
cmpq %rdx, %rcx
movzbl %al, %eax
cmovel %ebp, %eax
incq %rcx
cmpq $0x5b, %rcx
jne 0x2a4f
testb $0x1, %al
jne 0x2a40
movq %rbx, %rdi
callq 0x2566
leaq 0x20(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
leaq 0x38(%rsp), %rbp
leaq 0x27d0(%rip), %rsi      # 0x5260
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rbp, -0x10(%rbp)
leaq 0x28(%rsp), %rdi
callq 0x35d4
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x2aca
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2566
movaps 0x2537(%rip), %xmm0     # 0x5010
movups %xmm0, 0xa(%r13)
movups %xmm0, (%r13)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2afa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b0b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b25
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::newRandomMessage()
void Cryptogram::newRandomMessage()
{
    int lines;
    do{
        system("fortune > tmp.tmp");
        loadFile("tmp.tmp");
        lines = 0;
        for (string::iterator c = cyphertext.begin(); 
             c != cyphertext.end(); 
             c++)
        {
            if (*c == '\n')
                lines++;
        }
    }while((lines < 3) || (lines > 8));
    randomizeMessage();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2691(%rip), %r14      # 0x51ce
leaq 0x2694(%rip), %r15      # 0x51d8
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2628
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2b44
movq (%rbx), %rcx
xorl %esi, %esi
xorl %edx, %edx
xorl %edi, %edi
cmpb $0xa, (%rcx,%rsi)
sete %dil
addl %edi, %edx
incq %rsi
cmpq %rsi, %rax
jne 0x2b67
addl $-0x9, %edx
cmpl $-0x6, %edx
jb 0x2b44
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2a0e
// File: /workspace/github_cpp_makefile_star2_O1/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::letterDistribution(char*, int*)
void Cryptogram::letterDistribution(char letters[], int counts[])
{
    char letter;
    for (char c = 'A'; c <= 'Z'; c++)
    {
        letters[c-'A'] = c;
        counts[c-'A'] = 0;
    }
    for (string::iterator t = cyphertext.begin(); t != cyphertext.end(); t++)
    {
        letter = normalize(*t);
        if (isKey(letter))
            counts[letter-'A']++;
    }
    // BUBBLESORT!  YEAY!
    int tempInt;
    char tempChar;
    for (int i=0; i < 26; i++)
        for (int j = i; j < 26; j++)
            if (counts[j] > counts[i])
            {
                tempChar = letters[i];
                letters[i] = letters[j];
                letters[j] = tempChar;
                tempInt = counts[i];
                counts[i] = counts[j];
                counts[j] = tempInt;
            }
}

// Assembly:
xorl %eax, %eax
leal 0x41(%rax), %ecx
movb %cl, (%rsi,%rax)
movl $0x0, (%rdx,%rax,4)
incq %rax
cmpq $0x1a, %rax
jne 0x2b92
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2bed
movq (%rdi), %rcx
xorl %edi, %edi
movzbl (%rcx,%rdi), %r9d
leal -0x61(%r9), %r8d
leal -0x20(%r9), %r10d
cmpb $0x1a, %r8b
movzbl %r10b, %r8d
cmovael %r9d, %r8d
leal -0x41(%r8), %r9d
cmpb $0x19, %r9b
ja 0x2be5
movzbl %r8b, %r8d
incl -0x104(%rdx,%r8,4)
incq %rdi
cmpq %rdi, %rax
jne 0x2bb6
xorl %eax, %eax
movq %rax, %rcx
movl (%rdx,%rcx,4), %edi
cmpl (%rdx,%rax,4), %edi
jle 0x2c18
movb (%rsi,%rax), %dil
movb (%rsi,%rcx), %r8b
movb %r8b, (%rsi,%rax)
movb %dil, (%rsi,%rcx)
movl (%rdx,%rax,4), %edi
movl (%rdx,%rcx,4), %r8d
movl %r8d, (%rdx,%rax,4)
movl %edi, (%rdx,%rcx,4)
incq %rcx
cmpq $0x1a, %rcx
jne 0x2bf2
incq %rax
cmpq $0x1a, %rax
jne 0x2bef
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::paintAlphabet(_win_st*)
void Cryptogram::paintAlphabet(WINDOW *w)
{
    // Print the alphabet...
    char used[26];
    bool duplicates = false;
    char letter;
    
    for (int i=0; i<26; i++)
        used[i] = 0;

    wcolor_set(w, 2, NULL);
    wmove(w, 0, 0);
    wprintw(w, "Cyphertext: ");
    for (char c='A'; c <= 'Z'; c++)
        wprintw(w, "%c", c);
    wprintw(w, "\nPlaintext:  ");
    for (int i=0; i<26; i++)
    {
        letter = alphabet[i];
        wprintw(w, "%c", letter);
        if (isKey(letter))
        {
            if (used[letter-'A'] == 1)
                duplicates = true;
            else
                used[letter-'A'] = 1;
        }
    }
    if (duplicates)
        wprintw(w, " <-- Warning: duplicates");
    else
        wprintw(w, "                        ");
    mvwprintw(w, 2, 0, "%s %s by %s", PROGNAME, PROGVER, BYLINE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x1a(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2260
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq 0x200b(%rip), %rsi      # 0x5212
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x41, %ebp
leaq 0x2002(%rip), %r15      # 0x521f
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2030
incl %ebp
cmpl $0x5b, %ebp
jne 0x321d
leaq 0x1fe8(%rip), %rsi      # 0x5222
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x10(%rsp), %rbp
xorl %r15d, %r15d
movsbl 0x40(%r14,%r15), %r12d
movq %rbx, %rdi
leaq 0x1fc0(%rip), %rsi      # 0x521f
movl %r12d, %edx
xorl %eax, %eax
callq 0x2030
leal -0x41(%r12), %eax
cmpb $0x19, %al
ja 0x328c
movslq %r12d, %rax
cmpb $0x1, -0x41(%rax,%rbp)
movb $0x1, -0x41(%rax,%rbp)
movzbl %r13b, %r13d
movl $0x1, %eax
cmovel %eax, %r13d
incq %r15
cmpq $0x1a, %r15
jne 0x324f
leaq 0x1f94(%rip), %rax      # 0x5230
leaq 0x1fa6(%rip), %rsi      # 0x5249
testb $0x1, %r13b
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x1fc2(%rip), %rax      # 0x527e
movq %rax, (%rsp)
leaq 0x1f9b(%rip), %rcx      # 0x5262
leaq 0x1fa0(%rip), %r8       # 0x526e
leaq 0x1fa4(%rip), %r9       # 0x5279
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3417
leaq 0x1f63(%rip), %r15      # 0x52a0
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 0x3360
testl %ecx, %ecx
jne 0x3363
jmp 0x3368
movb $0x0, (%rax)
incq %rax
jmp 0x3352
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 0x33ba
testl %ecx, %ecx
jne 0x33bd
jmp 0x33c2
movb $0x0, (%rax)
incq %rax
jmp 0x33ac
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 0x3340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b90
movq %rsp, %rdi
callq 0x2c2c
movq %rbx, %rdi
callq 0x2190
leaq 0x1e46(%rip), %rcx      # 0x52a4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
leaq 0x1e61(%rip), %r14      # 0x52dc
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 0x347e
leaq 0x8(%rsp), %r14
cmpq 0x10(%r14), %r14
je 0x3521
leaq 0x1e14(%rip), %r15      # 0x52e4
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 0x3521
movq %rax, %r14
leal 0x1(%r12), %eax
cmpl $0xc, %r12d
movl %eax, %r12d
jb 0x34d3
movq %rsp, %rdi
callq 0x355c
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x353d
jmp 0x353d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x355c
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b2e(%rip), %rcx      # 0x52e8
leaq 0x1bc7(%rip), %r8       # 0x5388
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 0x31c4
movq %r12, %rdi
movq %r14, %rsi
callq 0x32f6
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_O1/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 0x4052(%rip), %r13      # 0x7fc8
movl (%r13), %edx
movq %rax, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2310
movq %rax, %r15
movq 0x402a(%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 0x377c
movq %r14, %rdi
xorl %esi, %esi
movl $0x3a, %edx
callq 0x21b0
movq %r14, %rdi
callq 0x21d0
callq 0x21e0
movq 0x3fa4(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
callq 0x20b0
movl %eax, %ebp
callq 0x20a0
movl %ebp, %eax
andl $0xdf, %eax
cmpl $0x51, %eax
je 0x406b
movsbl %bpl, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x3de4
jmp 0x4008
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a2
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x2628
movq %rsp, %rdi
callq 0x3f59
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_O1/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 %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%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 0x22e0
movq 0x18(%rsp), %r12
testq %r12, %r12
je 0x2719
movl $0x3, %r13d
leaq 0x10(%rsp), %r14
leaq 0x2a25(%rip), %rbp      # 0x5004
cmpq $0x3, %r12
cmovaeq %r13, %r12
movb $0x0, 0xa(%rsp)
movw $0x0, 0x8(%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2a64
movb (%rax), %al
movb %al, 0x8(%rsp,%r15)
incq %r15
cmpl %r12d, %r15d
jb 0x25f6
movzbl 0x8(%rsp), %ecx
movl %ecx, %eax
shrl $0x2, %eax
cmpl $0xcf, %ecx
ja 0x2628
cmpb $0x67, %cl
ja 0x2631
addb $0x41, %al
jmp 0x263b
cmpb $-0x9, %cl
ja 0x2635
addb $-0x4, %al
jmp 0x263b
addb $0x47, %al
jmp 0x263b
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 0x265d
cmpl $0x19, %ecx
ja 0x2667
addb $0x41, %cl
jmp 0x2672
cmpl $0x3d, %ecx
ja 0x266c
addb $-0x4, %cl
jmp 0x2672
addb $0x47, %cl
jmp 0x2672
addl $-0x3e, %ecx
movb (%rcx,%rbp), %cl
movzbl 0xa(%rsp), %esi
orl %esi, %edx
shrl $0x6, %edx
andl $0x3f, %edx
cmpl $0x33, %edx
ja 0x268e
cmpl $0x19, %edx
ja 0x2698
addb $0x41, %dl
jmp 0x26a3
cmpl $0x3d, %edx
ja 0x269d
addb $-0x4, %dl
jmp 0x26a3
addb $0x47, %dl
jmp 0x26a3
addl $-0x3e, %edx
movb (%rdx,%rbp), %dl
andl $0x3f, %esi
cmpl $0x33, %esi
ja 0x26b6
cmpl $0x19, %esi
ja 0x26c1
addb $0x41, %sil
jmp 0x26ce
cmpl $0x3d, %esi
ja 0x26c7
addb $-0x4, %sil
jmp 0x26ce
addb $0x47, %sil
jmp 0x26ce
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 %r15d, %r15d
movsbl 0xc(%rsp,%r15), %esi
movq %rbx, %rdi
callq 0x2180
incq %r15
leal -0x1(%r15), %eax
cmpl %r12d, %eax
jb 0x26f1
movq 0x18(%rsp), %r12
testq %r12, %r12
jne 0x25df
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x272f
jmp 0x272f
movq %rax, %r14
movq (%rbx), %rdi
movq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x274a
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d08
movq %rdi, %rbx
callq 0x2c95
movl (%rbx), %ebp
leaq 0x8(%rsp), %r14
leaq 0x5505(%rip), %r15      # 0x81e0
movq %r14, %rdi
callq 0x2a64
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 0x2cdb
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_O1/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 0x2de2
xorl %eax, %eax
jmp 0x2e1a
callq 0x2d48
movzbl %bpl, %eax
leaq 0x57f6(%rip), %rcx      # 0x85e8
movzbl (%rax,%rcx), %eax
movzbl %bl, %edx
movzbl (%rdx,%rcx), %edx
addl %eax, %edx
imulq $0x1010102, %rdx, %rax  # imm = 0x1010102
shrq $0x20, %rax
movl %eax, %esi
shll $0x8, %esi
subl %esi, %eax
addl %edx, %eax
movb 0x100(%rax,%rcx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d48
movzbl %bpl, %eax
leaq 0x57a6(%rip), %rcx      # 0x85e8
movzbl (%rax,%rcx), %eax
movzbl %bl, %edx
movzbl (%rdx,%rcx), %edx
subl %edx, %eax
leal 0xff(%rax), %edx
imulq $0x1010102, %rdx, %rdx  # imm = 0x1010102
shrq $0x20, %rdx
movl %edx, %esi
shll $0x8, %esi
subl %esi, %edx
addl %edx, %eax
addl $0xff, %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 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a64
movzbl (%rax), %edi
movzbl %r15b, %r15d
movl %r15d, %esi
callq 0x2dc8
xorb %al, %bl
movl %r15d, %edi
movl %ebp, %esi
callq 0x2dc8
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_O1/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, 0x4(%rsp)
xorl %eax, %eax
testl %esi, %esi
je 0x2fc9
movq %rdi, %r15
movl %esi, %r13d
xorl %r12d, %r12d
xorl %ecx, %ecx
movq %rsi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl %eax, %ebx
cmpq %rsi, %rbx
jae 0x2fdc
movb $0x1, %bpl
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x2f9a
cmpq 0x8(%rsp), %r14
jae 0x2fdc
movb (%r15,%r14,2), %al
movl %eax, %ecx
xorb 0x4(%rsp), %cl
xorb (%r15,%rbx,2), %al
movzbl %cl, %edi
movzbl %al, %esi
callq 0x2e21
movzbl %al, %esi
movzbl %bpl, %edi
callq 0x2dc8
movl %eax, %ebp
incq %r14
cmpq %r14, %r13
jne 0x2f67
movzbl 0x1(%r15,%rbx,2), %esi
movzbl %bpl, %edi
callq 0x2dc8
movq 0x10(%rsp), %rcx
xorb %al, %cl
leal 0x1(%rbx), %eax
incq %r12
movq 0x8(%rsp), %rsi
cmpl %esi, %eax
jne 0x2f55
jmp 0x2fcb
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20a4(%rip), %rdi      # 0x5087
leaq 0x20a9(%rip), %rsi      # 0x5093
leaq 0x20ae(%rip), %rcx      # 0x509f
movl $0x35, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59ec(%rip), %al       # 0x89f8
testb %al, %al
je 0x3051
leaq 0x57d9(%rip), %rax      # 0x87f0
movq 0x57d2(%rip), %rcx      # 0x87f0
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rcx,%rax)
jne 0x30a4
leaq 0x57c0(%rip), %rdi      # 0x87f0
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 0x59a0(%rip), %rdi      # 0x89f8
callq 0x2350
testl %eax, %eax
je 0x3010
leaq 0x5788(%rip), %rdi      # 0x87f0
leaq 0x20a7(%rip), %rsi      # 0x5116
movl $0xc, %edx
callq 0x2360
movq 0x4ef0(%rip), %rdi      # 0x7f70
leaq 0x5769(%rip), %rsi      # 0x87f0
leaq 0x5132(%rip), %rdx      # 0x81c0
callq 0x2190
leaq 0x595e(%rip), %rdi      # 0x89f8
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 0x2330
movq %rax, %rbx
leaq 0x58fa(%rip), %rdi      # 0x89f8
callq 0x20f0
jmp 0x3112
jmp 0x3107
movq %rax, %rbx
movq %r14, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c54
movl $0xff, %r13d
andl %r13d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x2c5c
andl %r13d, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x2c5c
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2cac
movq %r12, %rdi
callq 0x2d14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x381c
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 0x3888
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 0x448a
movq %r14, %rdi
callq 0x4502
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_O1/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 0x4b58
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 0x4cd0
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 0x42af
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 0x4f6a
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 0x4309
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 0x457a
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 0x457a
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jne 0x3ba2
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x4ff6
leaq 0x30(%r15), %rcx
cmpq %rcx, %rax
jne 0x3bb7
leaq 0x58(%r15), %rdi
movq %r14, %rsi
callq 0x5150
leaq 0x60(%r15), %rcx
cmpq %rcx, %rax
je 0x3bbe
xorl %eax, %eax
jmp 0x3c61
movl $0x88, %edi
callq 0x31b0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4ac8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3604
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3c0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
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 0x4ac8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3cba
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x3c4d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4392
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 0x3cb1
movq 0x30(%rsp), %rsi
incq %rsi
jmp 0x3cac
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3ca4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x3ca4
movq %rax, %r14
movl $0x88, %esi
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ff6
movq %rax, %r15
addq $0x30, %rbx
cmpq %rbx, %rax
je 0x3d15
movq 0x40(%r15), %r13
testq %r13, %r13
je 0x3cff
movq %r13, %rdi
callq 0x37a0
movl $0x88, %esi
movq %r13, %rdi
callq 0x31c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x51da
movq %r14, %rdi
movq %rax, %rsi
callq 0x5282
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq 0x70(%rdi), %r15
movq %rdi, 0x10(%rsp)
leaq 0x60(%rdi), %rbp
cmpq %rbp, %r15
je 0x3ddd
leaq 0x28(%rsp), %rbx
leaq 0x68(%rsp), %r14
leaq 0x58(%rsp), %r12
leaq 0x18(%rsp), %r13
movq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x59a8
movq 0x40(%r15), %rax
movq %rbx, 0x18(%rsp)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4ac8
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x3f1a
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3db6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dcd
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %r15, %rdi
callq 0x3130
movq %rax, %r15
cmpq %rbp, %rax
jne 0x3d62
movq 0x10(%rsp), %r14
movq 0x40(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x3ebc
leaq 0x48(%rsp), %rbx
movq 0x8(%rsp), %rax
leaq 0x28(%rax), %rbp
leaq 0x7fc5(%rip), %r13      # 0xbdcd
leaq 0x20(%r15), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3090
testl %eax, %eax
je 0x3ea8
movq %r12, %rdi
leaq 0x71dc(%rip), %rsi      # 0xb005
callq 0x3090
testl %eax, %eax
je 0x3ea8
movq %r12, %rdi
leaq 0x71c8(%rip), %rsi      # 0xb004
callq 0x3090
testl %eax, %eax
je 0x3ea8
movq 0x40(%r15), %rax
movq %rbx, 0x38(%rsp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x4ac8
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3b76
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3e8c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x40(%r15), %r12
leaq 0x8(%r12), %rsi
movq %rbp, %rdi
callq 0x4392
movq (%rax), %rsi
movq %r12, %rdi
callq 0x3d25
movq %r15, %rdi
callq 0x3130
movq %rax, %r15
cmpq %r14, %rax
jne 0x3e08
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x38(%rsp), %rdi
movq %rbx, %r14
cmpq %rbx, %rdi
jne 0x3f06
jmp 0x3f11
movq %rax, %r15
jmp 0x3efc
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3efc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x3f11
movq (%r14), %rsi
incq %rsi
callq 0x31c0
movq %r15, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5150
leaq 0x60(%r15), %rcx
cmpq %rcx, %rax
jne 0x3f5e
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x4ff6
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 0x4ac8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5886
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 0x4ac8
movq %r15, %rdi
movq %r12, %rsi
callq 0x4194
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 0x440e
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_O1/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 0x4159
leaq 0x6f65(%rip), %rsi      # 0xb005
movq %rbx, %rdi
callq 0x3090
testl %eax, %eax
je 0x4159
leaq 0x6f4d(%rip), %rsi      # 0xb004
movq %rbx, %rdi
callq 0x3090
testl %eax, %eax
je 0x4159
leaq 0x28(%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4ff6
addq $0x30, %r12
cmpq %r12, %rax
setne %bpl
je 0x415b
movq 0x40(%rax), %r13
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x4ac8
movq %r14, %rdi
movq %r12, %rsi
callq 0x3cba
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x412f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4392
movq %r13, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x51da
movq %r15, %rdi
movq %rax, %rsi
callq 0x5282
jmp 0x415b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x418b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5150
movq %rax, %r15
addq $0x60, %rbx
cmpq %rbx, %rax
je 0x4217
movq 0x40(%r15), %r13
testq %r13, %r13
je 0x4201
movq 0x28(%r13), %rdi
leaq 0x38(%r13), %rax
cmpq %rax, %rdi
je 0x41dc
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%r13), %rdi
leaq 0x18(%r13), %rax
cmpq %rax, %rdi
je 0x41f4
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movl $0x48, %esi
movq %r13, %rdi
callq 0x31c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x567e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5726
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ac8
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5b0c
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a63
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x5a7a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb537(%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 0x5ace
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5ace
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x5ae5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb4cc(%rip), %rsi      # 0x10fb8
leaq 0x58(%rsp), %rdi
callq 0x3160
leaq 0xd8(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x32d0
nop