LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::loadKeys(char const*)
void Cryptogram::loadKeys(const char *filename)
{
    FILE *f;
    unsigned int i;
    f = fopen(filename, "rb");
    if (!f)
        return;
    for (i=0; i<sizeof(alphabet); i++)
        alphabet[i] = ' ';
    fread(alphabet, 1, sizeof(alphabet), f);
    fclose(f);
    for (i=0; i<sizeof(alphabet); i++)
        if ((alphabet[i] < 'A') || (alphabet[i] > 'Z'))
            alphabet[i] = ' ';
    calcPlaintext();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x35be(%rip), %rsi      # 0x61a1
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2bf8
jmp 0x2c97
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x1a, %rax
jae 0x2c1f
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x20, 0x40(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bff
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x1a, %edx
callq 0x23d0
movq -0x18(%rbp), %rdi
callq 0x2220
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x1a, %rax
jae 0x2c8e
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl 0x40(%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x2c75
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl 0x40(%rax,%rcx), %eax
cmpl $0x5a, %eax
jle 0x2c81
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x20, 0x40(%rax,%rcx)
jmp 0x2c83
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c4a
movq -0x28(%rbp), %rdi
callq 0x26b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::set(char, char)
void Cryptogram::set(char cypherLetter, char plainLetter)
{
    // Normalize to uppercase
    cypherLetter = normalize(cypherLetter);
    plainLetter = normalize(plainLetter);
    if (isKey(cypherLetter))
        alphabet[cypherLetter - 'A'] = plainLetter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x2d10
movb %al, -0x9(%rbp)
movsbl -0xa(%rbp), %edi
callq 0x2d10
movb %al, -0xa(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x2d50
testb $0x1, %al
jne 0x2ce6
jmp 0x2cfb
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %dl
movsbl -0x9(%rbp), %ecx
subl $0x41, %ecx
movslq %ecx, %rcx
movb %dl, 0x40(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::isKey(char)
bool Cryptogram::isKey(char letter)
{
    bool result = false;
    if ( (letter >= 'A') && (letter <= 'Z') )
        result = true;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x41, %eax
jl 0x2d74
movsbl -0x1(%rbp), %eax
cmpl $0x5a, %eax
jg 0x2d74
movb $0x1, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::randomizeKeys()
void Cryptogram::randomizeKeys()
{
    // Probably a better way of doing this....
    int r1, r2;
    char temp;
    for (int i=0; i<26; i++)
        alphabet[i] = i + 'A';
    srand(time(NULL));
    for (int i=0; i<1000; i++)
    {
        r1 = rand() % 26;
        r2 = rand() % 26;
        temp = alphabet[r1];
        alphabet[r1] = alphabet[r2];
        alphabet[r2] = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1a, -0x18(%rbp)
jge 0x2df0
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x41, %ecx
movb %cl, %dl
movslq -0x18(%rbp), %rcx
movb %dl, 0x40(%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2dcb
xorl %eax, %eax
movl %eax, %edi
callq 0x2200
movl %eax, %edi
callq 0x2210
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x2e65
callq 0x20a0
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
callq 0x20a0
movl $0x1a, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movb 0x40(%rax,%rcx), %cl
movb %cl, -0x11(%rbp)
movslq -0x10(%rbp), %rcx
movb 0x40(%rax,%rcx), %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0x40(%rax,%rcx)
movb -0x11(%rbp), %dl
movslq -0x10(%rbp), %rcx
movb %dl, 0x40(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e07
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2380
movq -0x70(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x2db0
movl $0x0, -0x30(%rbp)
cmpl $0x1a, -0x30(%rbp)
jge 0x2ed2
movq -0x70(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl 0x40(%rax,%rcx), %eax
movl -0x30(%rbp), %ecx
addl $0x41, %ecx
cmpl %ecx, %eax
jne 0x2ec5
movb $0x1, -0x29(%rbp)
jmp 0x2ec7
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2ea4
jmp 0x2ed4
testb $0x1, -0x29(%rbp)
jne 0x2e90
movq -0x70(%rbp), %rdi
callq 0x26b0
jmp 0x2ee5
movq -0x70(%rbp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
callq 0x2030
jmp 0x2ef7
movq -0x70(%rbp), %rdi
callq 0x23e0
movq %rax, -0x80(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2410
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq 0x3324(%rip), %rsi      # 0x6244
leaq -0x60(%rbp), %rdi
callq 0x22c0
jmp 0x2f2b
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x2330
movq -0x88(%rbp), %rdi
callq 0x2180
leaq -0x61(%rbp), %rdi
callq 0x2290
movq -0x70(%rbp), %rdi
callq 0x26b0
jmp 0x2f63
movl $0x0, -0x68(%rbp)
cmpl $0x1a, -0x68(%rbp)
jge 0x2fad
movq -0x70(%rbp), %rax
movslq -0x68(%rbp), %rcx
movb $0x20, 0x40(%rax,%rcx)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2f6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2fbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x2290
jmp 0x2fbf
leaq -0x28(%rbp), %rdi
callq 0x2180
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x2180
movq -0x38(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x31b7(%rip), %rdi      # 0x61b2
callq 0x21e0
movq -0x30(%rbp), %rdi
leaq 0x31b1(%rip), %rsi      # 0x61bc
callq 0x2880
movq -0x30(%rbp), %rdi
movl $0x0, -0xc(%rbp)
callq 0x21f0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4040
testb $0x1, %al
jne 0x3044
jmp 0x3071
leaq -0x18(%rbp), %rdi
callq 0x4080
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x305e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3060
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x40a0
movq %rax, -0x28(%rbp)
jmp 0x3024
jmp 0x3073
movb $0x1, %al
cmpl $0x3, -0xc(%rbp)
movb %al, -0x31(%rbp)
jl 0x3088
cmpl $0x8, -0xc(%rbp)
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2ff4
movq -0x30(%rbp), %rdi
callq 0x2e70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x1a, -0x38(%rbp)
jge 0x3a7d
movslq -0x38(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3a63
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2390
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2260
movq -0x10(%rbp), %rdi
leaq 0x274f(%rip), %rsi      # 0x61f6
movb $0x0, %al
callq 0x2040
movb $0x41, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x5a, %eax
jg 0x3adb
movq -0x10(%rbp), %rdi
movsbl -0x39(%rbp), %edx
leaq 0x2739(%rip), %rsi      # 0x6203
movb $0x0, %al
callq 0x2040
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x3ab2
movq -0x10(%rbp), %rdi
leaq 0x2720(%rip), %rsi      # 0x6206
movb $0x0, %al
callq 0x2040
movl $0x0, -0x40(%rbp)
cmpl $0x1a, -0x40(%rbp)
jge 0x3b64
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb 0x40(%rax,%rcx), %al
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x32(%rbp), %edx
leaq 0x26eb(%rip), %rsi      # 0x6203
movb $0x0, %al
callq 0x2040
movsbl -0x32(%rbp), %edi
callq 0x2d50
testb $0x1, %al
jne 0x3b2e
jmp 0x3b57
movsbl -0x32(%rbp), %eax
subl $0x41, %eax
cltq
movsbl -0x30(%rbp,%rax), %eax
cmpl $0x1, %eax
jne 0x3b47
movb $0x1, -0x31(%rbp)
jmp 0x3b55
movsbl -0x32(%rbp), %eax
subl $0x41, %eax
cltq
movb $0x1, -0x30(%rbp,%rax)
jmp 0x3b57
jmp 0x3b59
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3af4
testb $0x1, -0x31(%rbp)
je 0x3b7e
movq -0x10(%rbp), %rdi
leaq 0x269f(%rip), %rsi      # 0x6214
movb $0x0, %al
callq 0x2040
jmp 0x3b90
movq -0x10(%rbp), %rdi
leaq 0x26a4(%rip), %rsi      # 0x622d
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
leaq 0x26a4(%rip), %rcx      # 0x6246
leaq 0x26a9(%rip), %r8       # 0x6252
leaq 0x26ad(%rip), %r9       # 0x625d
leaq 0x26ab(%rip), %rax      # 0x6262
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2090
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2240
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2390
movq -0x8(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x2130
movq -0x8(%rbp), %rdi
xorl %edx, %edx
leaq 0xf9a(%rip), %rcx       # 0x62cc
leaq 0x1257(%rip), %r8       # 0x6590
movl %edx, %esi
movb $0x0, %al
callq 0x2090
movq -0x8(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x2350
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x3a, %edx
callq 0x2260
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3bd0
movq -0x8(%rbp), %rdi
callq 0x22d0
movq -0x10(%rbp), %rdi
callq 0x22d0
movq -0x18(%rbp), %rdi
callq 0x22d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x23b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x3468(%rip), %rax      # 0x8fc8
movl (%rax), %edx
movl $0x1, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x2450
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x343f(%rip), %rax      # 0x8fc0
movl (%rax), %esi
subl $0x4, %esi
movq 0x343b(%rip), %rax      # 0x8fc8
movl (%rax), %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2450
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x341d(%rip), %rax      # 0x8fc8
movl (%rax), %edx
movq 0x340c(%rip), %rax      # 0x8fc0
movl (%rax), %ecx
subl $0x3, %ecx
movl $0x3, %esi
xorl %r8d, %r8d
callq 0x2450
movq %rax, -0x28(%rbp)
callq 0x2080
movl $0x1, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2050
movl $0x2, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x2050
movl $0x3, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2050
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
callq 0x52e0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3a, %edx
callq 0x2260
movq -0x10(%rbp), %rdi
callq 0x22d0
callq 0x22e0
movq 0x33a4(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
callq 0x20e0
movb %al, -0x29(%rbp)
callq 0x20c0
movsbl -0x29(%rbp), %eax
cmpl $0x71, %eax
je 0x5c5e
movsbl -0x29(%rbp), %eax
cmpl $0x51, %eax
jne 0x5c60
jmp 0x5c7d
movb -0x29(%rbp), %al
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %r8
movsbl %al, %edi
callq 0x59b0
jmp 0x5c02
callq 0x22f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2580
cmpl $0x2, -0x8(%rbp)
jne 0x5cf3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2880
jmp 0x5cd1
jmp 0x5cf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2680
jmp 0x5d19
leaq -0x88(%rbp), %rdi
callq 0x5b40
jmp 0x5d01
leaq -0x88(%rbp), %rdi
callq 0x2680
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x2400
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x22c0
leaq -0x18(%rbp), %rdi
callq 0x2af0
movq %rax, -0x50(%rbp)
jmp 0x251a
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
leaq 0x2(,%rax,4), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %rsi
shrq %rsi
callq 0x2320
jmp 0x2544
jmp 0x2546
leaq -0x18(%rbp), %rdi
callq 0x2b10
movb %al, -0x61(%rbp)
jmp 0x2554
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2560
jmp 0x2664
leaq -0x18(%rbp), %rdi
callq 0x2af0
movq %rax, -0x70(%rbp)
jmp 0x256f
movq -0x70(%rbp), %rax
cmpq $0x3, %rax
jbe 0x2584
movl $0x3, %eax
movq %rax, -0x78(%rbp)
jmp 0x259d
leaq -0x18(%rbp), %rdi
callq 0x2af0
movq %rax, -0x80(%rbp)
jmp 0x2593
movq -0x80(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x259d
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x3b(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x20d0
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpq -0x38(%rbp), %rax
jae 0x2609
leaq -0x18(%rbp), %rdi
callq 0x2b30
movq %rax, -0x88(%rbp)
jmp 0x25d7
movq -0x88(%rbp), %rax
movb (%rax), %cl
movl -0x40(%rbp), %eax
movb %cl, -0x3b(%rbp,%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x25bc
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20f0
jmp 0x2684
leaq -0x3b(%rbp), %rdi
callq 0x2690
movl %eax, -0x8c(%rbp)
jmp 0x261a
movl -0x8c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x38(%rbp), %rax
jae 0x265f
movq -0x60(%rbp), %rdi
movl -0x48(%rbp), %eax
movsbl -0x44(%rbp,%rax), %esi
callq 0x2100
jmp 0x2652
jmp 0x2654
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2636
jmp 0x2546
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2677
movq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::triple::encode() const
quad triple::encode() const
{
	std::uint32_t temp =
		(static_cast<std::uint32_t>(octets[0]) << 16) |
		(static_cast<std::uint32_t>(octets[1]) <<  8) |
		(static_cast<std::uint32_t>(octets[2])      );
	quad ret = {{
		num_to_char((temp >> 18)     ),
		num_to_char((temp >> 12) & 63),
		num_to_char((temp >>  6) & 63),
		num_to_char((temp      ) & 63)
	}};
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movzbl (%rcx), %eax
shll $0x10, %eax
movzbl 0x1(%rcx), %edx
shll $0x8, %edx
orl %edx, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
shrl $0x12, %edi
callq 0x2950
movb %al, -0x4(%rbp)
movl -0x14(%rbp), %edi
shrl $0xc, %edi
andl $0x3f, %edi
callq 0x2950
movb %al, -0x3(%rbp)
movl -0x14(%rbp), %edi
shrl $0x6, %edi
andl $0x3f, %edi
callq 0x2950
movb %al, -0x2(%rbp)
movl -0x14(%rbp), %edi
andl $0x3f, %edi
callq 0x2950
movb %al, -0x1(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sellibitze[P]secretshare-cxx/base64.cpp
// Function: base64_dec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<unsigned char> base64_dec(std::string const& text)
{
	std::vector<unsigned char> temp;
	temp.reserve(text.size()*3/4);
	for (std::size_t pos=0; pos+2<=text.size(); pos+=4) {
		quad q = {{'A', 'A', 'A', 'A'}};
		auto remain = text.size() - pos;
		auto csize = remain>4 ? 4 : remain;
		for (unsigned k=0; k<csize; ++k) q.ascii[k] = text[pos+k];
		triple t = q.decode();
		csize -= 1; // n+1 characters => n bytes (for 1<=n<=3)
		for (unsigned k=0; k<csize; ++k) temp.push_back(t.octets[k]);
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2be0
movq -0x10(%rbp), %rdi
callq 0x2150
movq -0x60(%rbp), %rdi
leaq (%rax,%rax,2), %rsi
shrq $0x2, %rsi
callq 0x2c00
jmp 0x2743
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
ja 0x286a
movl 0x688e(%rip), %eax      # 0x9004
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x4, -0x40(%rbp)
jbe 0x279c
movl $0x4, %eax
movq %rax, -0x78(%rbp)
jmp 0x27a4
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpq -0x48(%rbp), %rax
jae 0x27fd
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x4c(%rbp), %eax
addq %rax, %rsi
callq 0x2200
movb (%rax), %cl
movl -0x4c(%rbp), %eax
movb %cl, -0x34(%rbp,%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x27b3
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2d50
jmp 0x288a
leaq -0x34(%rbp), %rdi
callq 0x28a0
movl %eax, -0x7c(%rbp)
jmp 0x280b
movl -0x7c(%rbp), %eax
movw %ax, %cx
movw %cx, -0x4f(%rbp)
shrl $0x10, %eax
movb %al, -0x4d(%rbp)
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpq -0x48(%rbp), %rax
jae 0x2857
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %eax
leaq -0x4f(%rbp,%rax), %rsi
callq 0x2ce0
jmp 0x284a
jmp 0x284c
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x282e
jmp 0x2859
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x274b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x287d
movq -0x60(%rbp), %rdi
callq 0x2d50
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::quad::decode() const
triple quad::decode() const
{
	std::uint32_t temp =
		(char_to_num(ascii[0]) << 18) |
		(char_to_num(ascii[1]) << 12) |
		(char_to_num(ascii[2]) <<  6) |
		(char_to_num(ascii[3])      );
	triple ret = {{
		static_cast<unsigned char>((temp >> 16)       ),
		static_cast<unsigned char>((temp >>  8) & 0xFF),
		static_cast<unsigned char>((temp      ) & 0xFF)
	}};
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl (%rax), %edi
callq 0x29e0
movl %eax, %ecx
movq -0x28(%rbp), %rax
shll $0x12, %ecx
movl %ecx, -0x30(%rbp)
movsbl 0x1(%rax), %edi
callq 0x29e0
movl -0x30(%rbp), %ecx
movl %eax, %edx
movq -0x28(%rbp), %rax
shll $0xc, %edx
orl %edx, %ecx
movl %ecx, -0x2c(%rbp)
movsbl 0x2(%rax), %edi
callq 0x29e0
movl -0x2c(%rbp), %ecx
movl %eax, %edx
movq -0x28(%rbp), %rax
shll $0x6, %edx
orl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movsbl 0x3(%rax), %edi
callq 0x29e0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x3(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x2(%rbp)
movb -0x14(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x16(%rbp)
movw -0x3(%rbp), %ax
movw %ax, -0x18(%rbp)
movzbl -0x16(%rbp), %ecx
shll $0x10, %ecx
movzwl -0x18(%rbp), %eax
orl %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::num_to_char(unsigned int)
inline char num_to_char(std::uint32_t num)
{
	if (num < 52) {
		if (num < 26) return char('A' + num);
		return char('a' + (num - 26));
	} else {
		if (num < 62) return char('0' + (num - 52));
		if (num < 64) return "+/"[num - 62];
		assert(!"Illegal Base64 character index");
		throw std::domain_error("Illegal Base64 character index");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x34, -0x8(%rbp)
jae 0x2980
cmpl $0x1a, -0x8(%rbp)
jae 0x2972
movl -0x8(%rbp), %eax
addl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x29d2
movl -0x8(%rbp), %eax
subl $0x1a, %eax
addl $0x61, %eax
movb %al, -0x1(%rbp)
jmp 0x29d2
cmpl $0x3e, -0x8(%rbp)
jae 0x2994
movl -0x8(%rbp), %eax
subl $0x34, %eax
addl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x29d2
cmpl $0x40, -0x8(%rbp)
jae 0x29b3
movl -0x8(%rbp), %eax
subl $0x3e, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x665d(%rip), %rax      # 0x9008
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x29d2
leaq 0x6651(%rip), %rdi      # 0x900b
leaq 0x666c(%rip), %rsi      # 0x902d
movl $0x27, %edx
leaq 0x666b(%rip), %rcx      # 0x9038
callq 0x2140
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sellibitze[P]secretshare-cxx/base64.cpp
// Function: (anonymous namespace)::char_to_num(char)
inline std::uint32_t char_to_num(char c)
{
	if ('A' <= c && c <= 'Z') return c - 'A';
	if ('a' <= c && c <= 'z') return (c - 'a') + 26;
	if ('0' <= c && c <= '9') return (c - '0') + 52;
	if (c == '+') return 62;
	if (c == '/') return 63;
	throw std::domain_error("Illegal Base64 character found");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x2a13
movsbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jg 0x2a13
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ad4
movsbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x2a3b
movsbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2a3b
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0x1a, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ad4
movsbl -0x5(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x2a60
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x2a60
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
addl $0x34, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ad4
movsbl -0x5(%rbp), %eax
cmpl $0x2b, %eax
jne 0x2a72
movl $0x3e, -0x4(%rbp)
jmp 0x2ad4
movsbl -0x5(%rbp), %eax
cmpl $0x2f, %eax
jne 0x2a84
movl $0x3f, -0x4(%rbp)
jmp 0x2ad4
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x65d0(%rip), %rsi      # 0x906f
callq 0x2120
jmp 0x2aa6
movq -0x20(%rbp), %rdi
movq 0xb4df(%rip), %rsi      # 0xdf90
movq 0xb4e8(%rip), %rdx      # 0xdfa0
callq 0x2360
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2160
jmp 0x2add
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/./slice.hpp
// Function: slice<unsigned char const>::shift()
T& shift()
	{
		if (empty()) throw std::logic_error("slice already empty");
		auto old = base;
		++base;
		--len;
		return *old;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e60
testb $0x1, %al
jne 0x2b4f
jmp 0x2b9f
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x6524(%rip), %rsi      # 0x908e
callq 0x22e0
jmp 0x2b71
movq -0x30(%rbp), %rdi
movq 0xb44c(%rip), %rsi      # 0xdfc8
movq 0xb42d(%rip), %rdx      # 0xdfb0
callq 0x2360
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2160
jmp 0x2bca
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b10
testb $0x1, %al
jne 0x38db
jmp 0x3930
callq 0x3800
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b30
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x3870
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b10
testb $0x1, %al
jne 0x38f0
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/crc24.cpp
// Function: (anonymous namespace)::table::table()
table::table()
{
	for (std::uint32_t bite=0; bite<256; ++bite) {
		auto temp = bite << 16;
		for (int k=0; k<8; ++k) {
			temp = (temp << 1) ^ ((-(temp >> 23)) & REDUCE_POLY);
		}
		arr[bite] = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x39c3
movl -0xc(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x39ab
movl -0x10(%rbp), %eax
shll %eax
movl -0x10(%rbp), %edx
shrl $0x17, %edx
xorl %ecx, %ecx
subl %edx, %ecx
andl $0x1864cfb, %ecx        # imm = 0x1864CFB
xorl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3980
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3967
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
leaq -0x2(%rbp), %rdi
callq 0x3d70
movl %eax, -0x8(%rbp)
leaq -0x3(%rbp), %rdi
callq 0x3d70
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x3b48
cmpl $0x0, -0xc(%rbp)
jne 0x3b52
callq 0x3d90
movb %al, -0x1(%rbp)
jmp 0x3b9b
callq 0x3a10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movzbl 0x100(%rax,%rcx), %esi
leaq -0x1(%rbp), %rdi
callq 0x3d50
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
leaq -0x2(%rbp), %rdi
callq 0x3d70
movl %eax, -0x8(%rbp)
leaq -0x3(%rbp), %rdi
callq 0x3d70
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x3bef
callq 0x3d90
movb %al, -0x1(%rbp)
jmp 0x3c93
cmpl $0x0, -0xc(%rbp)
jne 0x3c45
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x54ce(%rip), %rsi      # 0x90de
callq 0x2120
jmp 0x3c17
movq -0x30(%rbp), %rdi
movq 0xa36e(%rip), %rsi      # 0xdf90
movq 0xa377(%rip), %rdx      # 0xdfa0
callq 0x2360
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2160
jmp 0x3c9c
callq 0x3a10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl -0x8(%rbp), %ecx
movzbl (%rax,%rcx), %eax
addl $0xff, %eax
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movq -0x38(%rbp), %rax
movslq %edx, %rcx
movzbl 0x100(%rax,%rcx), %esi
leaq -0x1(%rbp), %rdi
callq 0x3d50
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/gf256.cpp
// Function: (anonymous namespace)::tables::tables()
tables::tables()
{
	this->log[0] = 0; // invalid dummy
	for (unsigned p=0, f=1; p<255; ++p) {
		this->exp[p] = f;
		this->log[f] = p;
		f = mul_g(f);
	}
	this->exp[255] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, (%rax)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0xff, -0xc(%rbp)
jae 0x3d12
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movb %cl, %dl
movl -0xc(%rbp), %ecx
movb %dl, 0x100(%rax,%rcx)
movl -0xc(%rbp), %ecx
movb %cl, %dl
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %edi
callq 0x3d30
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cd5
movq -0x18(%rbp), %rax
movb $0x1, 0x1ff(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
leaq -0x12(%rbp), %rdi
callq 0x3d50
callq 0x3d90
movb %al, -0x13(%rbp)
callq 0x3fd0
movb %al, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b10
testb $0x1, %al
jne 0x3df1
jmp 0x3e46
leaq -0x10(%rbp), %rdi
callq 0x2b30
movzbl (%rax), %esi
leaq -0x15(%rbp), %rdi
callq 0x3d50
movb -0x15(%rbp), %al
movb %al, -0x17(%rbp)
movb -0x14(%rbp), %al
movb %al, -0x18(%rbp)
movb -0x17(%rbp), %al
movzbl %al, %edi
movzbl -0x18(%rbp), %esi
callq 0x3b10
movb %al, -0x16(%rbp)
leaq -0x13(%rbp), %rdi
movzbl -0x16(%rbp), %esi
callq 0x3ff0
movb -0x12(%rbp), %al
movb %al, -0x19(%rbp)
leaq -0x14(%rbp), %rdi
movzbl -0x19(%rbp), %esi
callq 0x4020
jmp 0x3de2
leaq -0x13(%rbp), %rdi
callq 0x3d70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movb %al, -0x11(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4070
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %esi
leaq -0x19(%rbp), %rdi
callq 0x3d50
callq 0x3d90
movb %al, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x3fc1
callq 0x3fd0
movb %al, -0x21(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x4090
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x3f7d
movl -0x20(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x3f6d
movl -0x34(%rbp), %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x4090
movq %rax, -0x40(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x43(%rbp)
movq -0x40(%rbp), %rax
movzbl (%rax), %esi
leaq -0x44(%rbp), %rdi
callq 0x3d50
movb -0x43(%rbp), %al
movzbl %al, %edi
movzbl -0x44(%rbp), %esi
callq 0x40f0
movb %al, -0x42(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %esi
leaq -0x46(%rbp), %rdi
callq 0x3d50
movq -0x40(%rbp), %rax
movzbl (%rax), %esi
leaq -0x47(%rbp), %rdi
callq 0x3d50
movb -0x46(%rbp), %al
movzbl %al, %edi
movzbl -0x47(%rbp), %esi
callq 0x40f0
movb %al, -0x45(%rbp)
movb -0x42(%rbp), %al
movzbl %al, %edi
movzbl -0x45(%rbp), %esi
callq 0x3bb0
movb %al, -0x41(%rbp)
leaq -0x21(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x4020
jmp 0x3f6f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3eca
movb -0x21(%rbp), %al
movb %al, -0x49(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %esi
leaq -0x4a(%rbp), %rdi
callq 0x3d50
movb -0x49(%rbp), %al
movzbl %al, %edi
movzbl -0x4a(%rbp), %esi
callq 0x3b10
movb %al, -0x48(%rbp)
leaq -0x1a(%rbp), %rdi
movzbl -0x48(%rbp), %esi
callq 0x3ff0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e9d
leaq -0x1a(%rbp), %rdi
callq 0x3d70
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
callq 0x4250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x414f
jmp 0x41a2
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x4fe4(%rip), %rsi      # 0x914e
callq 0x2060
jmp 0x4171
movq -0x30(%rbp), %rdi
movq 0x9e74(%rip), %rsi      # 0xdff0
movq 0x9e25(%rip), %rdx      # 0xdfa8
callq 0x2360
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2160
jmp 0x423b
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4300
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4320
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x2230
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x41e5
jmp 0x4235
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x4f6a(%rip), %rsi      # 0x916a
callq 0x2060
jmp 0x4207
movq -0x48(%rbp), %rdi
movq 0x9dde(%rip), %rsi      # 0xdff0
movq 0x9d8f(%rip), %rdx      # 0xdfa8
callq 0x2360
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2160
jmp 0x423b
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::do_encode(unsigned int, unsigned int)
void do_encode(unsigned k, unsigned n)
{
	binary_mode_for_stdin();
	auto v = read_secret_from(cin);
	auto shares = secret_share(v, k, n);
	for (const auto& s : shares) {
		cout << share_to_text(k, s, true) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
callq 0x4360
movq 0x99c3(%rip), %rsi      # 0xdfd0
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4830
movq -0xa0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7120
jmp 0x462f
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x4950
jmp 0x4649
leaq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4d00
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4d30
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4d60
testb $0x1, %al
jne 0x4681
jmp 0x4729
leaq -0x68(%rbp), %rdi
callq 0x4da0
movq %rax, -0x78(%rbp)
movl -0x4(%rbp), %esi
movq -0x78(%rbp), %rdx
leaq -0x98(%rbp), %rdi
movl $0x1, %ecx
callq 0x4dc0
jmp 0x46a8
movq 0x9909(%rip), %rdi      # 0xdfb8
leaq -0x98(%rbp), %rsi
callq 0x2190
movq %rax, -0xa8(%rbp)
jmp 0x46c4
movq -0xa8(%rbp), %rdi
movq 0x98b6(%rip), %rsi      # 0xdf88
callq 0x21f0
jmp 0x46d9
leaq -0x98(%rbp), %rdi
callq 0x20f0
leaq -0x68(%rbp), %rdi
callq 0x5020
jmp 0x466b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x474d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4744
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20f0
jmp 0x4744
leaq -0x38(%rbp), %rdi
callq 0x5040
leaq -0x20(%rbp), %rdi
callq 0x2d50
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5040
leaq -0x20(%rbp), %rdi
callq 0x2d50
movq -0x50(%rbp), %rdi
callq 0x2370
nop
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::do_decode()
void do_decode()
{
	auto shares = read_shares_from(cin);
	auto secret = decode_secret(shares);
	binary_mode_for_stdout();
	cout.write(reinterpret_cast<const char*>(secret.data()), secret.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x9861(%rip), %rsi      # 0xdfd0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5a30
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x6070
jmp 0x478b
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5de0
jmp 0x479e
callq 0x4370
jmp 0x47a5
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7bd0
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x3090
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movq 0x97eb(%rip), %rdi      # 0xdfb8
callq 0x2270
jmp 0x47d4
leaq -0x30(%rbp), %rdi
callq 0x2d50
leaq -0x18(%rbp), %rdi
callq 0x5040
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x480f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d50
leaq -0x18(%rbp), %rdi
callq 0x5040
movq -0x48(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::read_secret_from(std::istream&)
vector<octet> read_secret_from(istream& in)
{
	vector<octet> result;
	octet temp;
	char& alias = reinterpret_cast<char&>(temp);
	// ^ is OK according to aliasing rules because temp and alias
	// are both referring to something of a character type.
	while (in.get(alias)) {
		if (result.size() == 0x10000U) {
			throw runtime_error("Secret too large. "
			                    "Do you really need more then 64KB?!");
		}
		result.push_back(temp);
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2be0
leaq -0x12(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22b0
movq %rax, -0x48(%rbp)
jmp 0x486f
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2220
movb %al, -0x49(%rbp)
jmp 0x4887
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4893
jmp 0x4918
movq -0x40(%rbp), %rdi
callq 0x3090
cmpq $0x10000, %rax          # imm = 0x10000
jne 0x4904
movl $0x10, %edi
callq 0x20b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x4a90(%rip), %rsi      # 0x934f
callq 0x2060
jmp 0x48c6
movq -0x58(%rbp), %rdi
movq 0x971f(%rip), %rsi      # 0xdff0
movq 0x96d0(%rip), %rdx      # 0xdfa8
callq 0x2360
jmp 0x4947
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x4935
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2160
jmp 0x4935
movq -0x40(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2ce0
jmp 0x4913
jmp 0x485c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x492b
movq -0x40(%rbp), %rdi
callq 0x2d50
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2d50
movq -0x28(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::share_to_text[abi:cxx11](unsigned int, (anonymous namespace)::share const&, bool)
string share_to_text(unsigned k, share const& s, bool with_checksum)
{
	ostringstream oss;
	unsigned n = s.xcoord;
	oss << k << '-' << n << '-' << base64_enc(s.data);
	if (with_checksum) {
		oss << '-' << crc24_to_text(compute_crc24(k, n, s.data));
	}
	return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x230(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x22a0
movq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x19c(%rbp)
movl -0xc(%rbp), %esi
callq 0x2290
movq %rax, -0x218(%rbp)
jmp 0x4e26
movq -0x218(%rbp), %rdi
movl $0x2d, %esi
callq 0x2210
movq %rax, -0x238(%rbp)
jmp 0x4e40
movq -0x238(%rbp), %rdi
movl -0x19c(%rbp), %esi
callq 0x2290
movq %rax, -0x240(%rbp)
jmp 0x4e5b
movq -0x240(%rbp), %rdi
movl $0x2d, %esi
callq 0x2210
movq %rax, -0x248(%rbp)
jmp 0x4e75
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x7c40
jmp 0x4e8b
movq -0x1e0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
leaq -0x1d0(%rbp), %rdi
callq 0x24e0
jmp 0x4ea7
movq -0x248(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2190
jmp 0x4ebc
leaq -0x1d0(%rbp), %rdi
callq 0x20f0
testb $0x1, -0x19(%rbp)
je 0x4fc9
leaq -0x198(%rbp), %rdi
movl $0x2d, %esi
callq 0x2210
movq %rax, -0x250(%rbp)
jmp 0x4eec
movl -0xc(%rbp), %eax
movl %eax, -0x258(%rbp)
movl -0x19c(%rbp), %eax
movl %eax, -0x254(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x210(%rbp), %rdi
callq 0x7c40
jmp 0x4f17
movl -0x254(%rbp), %esi
movl -0x258(%rbp), %edi
movq -0x210(%rbp), %rdx
movq -0x208(%rbp), %rcx
callq 0x5990
movl %eax, -0x25c(%rbp)
jmp 0x4f3e
movl -0x25c(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x5920
jmp 0x4f52
movq -0x250(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x2190
jmp 0x4f67
leaq -0x200(%rbp), %rdi
callq 0x20f0
jmp 0x4fc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x4ffa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x20f0
jmp 0x4ffa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x20f0
jmp 0x4ffa
movq -0x230(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21d0
jmp 0x4fde
leaq -0x198(%rbp), %rdi
callq 0x2030
movq -0x228(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x2030
movq -0x1a8(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::crc24_to_text[abi:cxx11](unsigned int)
string crc24_to_text(uint32_t crc24)
{
	const octet bytes[] = {
		static_cast<octet>((crc24 >> 16) & 0xFF),
		static_cast<octet>((crc24 >>  8) & 0xFF),
		static_cast<octet>((crc24      ) & 0xFF)
	};
	return base64_enc(bytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0xf(%rbp), %rsi
callq 0x7cb0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)