LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: execute(char const*)
int execute(const char *p)
{
    vector<uint> code;
    code.reserve(64);
    compilemain(code, p, VAL_INT);
    tagval result;
    runcode(code.getbuf()+1, result);
    if(int(code[0]) >= 0x100) code.disown();
    int i = result.getint();
    freearg(result);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x15d60
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x40, %edx
callq 0x15d90
jmp 0xaf70
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movl $0x1, %edx
callq 0x6530
jmp 0xaf84
leaq -0x18(%rbp), %rdi
callq 0x15e20
movq %rax, -0x68(%rbp)
jmp 0xaf93
movq -0x68(%rbp), %rdi
addq $0x4, %rdi
leaq -0x50(%rbp), %rsi
callq 0x6960
jmp 0xafa6
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x15ea0
movq %rax, -0x70(%rbp)
jmp 0xafb7
movq -0x70(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0xafe7
leaq -0x18(%rbp), %rdi
callq 0x15ee0
jmp 0xafce
jmp 0xafe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e40
jmp 0xb021
leaq -0x50(%rbp), %rdi
callq 0x15f10
movl %eax, -0x74(%rbp)
jmp 0xaff5
movl -0x74(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4500
jmp 0xb006
movl -0x54(%rbp), %eax
movl %eax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e40
movl -0x78(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x23e0
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: executebool(unsigned int const*)
bool executebool(const uint *code)
{
    tagval result;
    runcode(code, result);
    bool b = getbool(result);
    freearg(result);
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6960
leaq -0x18(%rbp), %rdi
callq 0xb070
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4500
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: getbool(tagval const&)
static inline bool getbool(const tagval &v)
{
    switch(v.type)
    {
        case VAL_FLOAT: return v.f!=0;
        case VAL_INT: return v.i!=0;
        case VAL_STR: case VAL_MACRO: return getbool(v.s);
        default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0xb0e5
movq -0x18(%rbp), %rax
leaq 0x1257d(%rip), %rcx     # 0x1d618
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb0e9
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb0e9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14b00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb0e9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: execfile(char const*, bool)
bool execfile(const char *cfgfile, bool msg)
{
    string s;
    copystring(s, cfgfile);
    char *buf = loadfile(path(s), NULL);
    if(!buf)
    {
        if(msg) conoutf(CON_ERROR, "could not read \"%s\"", cfgfile);
        return false;
    }
    const char *oldsourcefile = sourcefile, *oldsourcestr = sourcestr;
    sourcefile = cfgfile;
    sourcestr = buf;
    execute(buf);
    sourcefile = oldsourcefile;
    sourcestr = oldsourcestr;
    delete[] buf;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x104, %edx            # imm = 0x104
callq 0x15f30
leaq -0x120(%rbp), %rdi
callq 0x183c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x199c0
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
jne 0xb1c0
testb $0x1, -0x11(%rbp)
je 0xb1b7
movq -0x10(%rbp), %rdx
movl $0x4, %edi
leaq 0x12e4b(%rip), %rsi     # 0x1dffb
movb $0x0, %al
callq 0x4190
movb $0x0, -0x1(%rbp)
jmp 0xb241
movq 0x1c539(%rip), %rax     # 0x27700
movq %rax, -0x130(%rbp)
movq 0x1c533(%rip), %rax     # 0x27708
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1c519(%rip)     # 0x27700
movq -0x128(%rbp), %rax
movq %rax, 0x1c513(%rip)     # 0x27708
movq -0x128(%rbp), %rdi
callq 0xaf40
movq -0x130(%rbp), %rax
movq %rax, 0x1c4f1(%rip)     # 0x27700
movq -0x138(%rbp), %rax
movq %rax, 0x1c4eb(%rip)     # 0x27708
movq -0x128(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpq $0x0, %rax
je 0xb23d
movq -0x140(%rbp), %rdi
callq 0x1b110
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: validateblock(char const*)
bool validateblock(const char *s)
{
    const int maxbrak = 100;
    static char brakstack[maxbrak];
    int brakdepth = 0;
    for(; *s; s++) switch(*s)
    {
        case '[': case '(': if(brakdepth >= maxbrak) return false; brakstack[brakdepth++] = *s; break;
        case ']': if(brakdepth <= 0 || brakstack[--brakdepth] != '[') return false; break;
        case ')': if(brakdepth <= 0 || brakstack[--brakdepth] != '(') return false; break;
        case '"': s = parsestring(s + 1); if(*s != '"') return false; break;
        case '/': if(s[1] == '/') return false; break;
        case '@': case '\f': return false;
    }
    return brakdepth == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x64, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb791
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0xc, %eax
je 0xb778
jmp 0xb65c
movl -0x1c(%rbp), %eax
subl $0x22, %eax
je 0xb73e
jmp 0xb66a
movl -0x1c(%rbp), %eax
subl $0x28, %eax
je 0xb6b5
jmp 0xb674
movl -0x1c(%rbp), %eax
subl $0x29, %eax
je 0xb714
jmp 0xb682
movl -0x1c(%rbp), %eax
subl $0x2f, %eax
je 0xb763
jmp 0xb690
movl -0x1c(%rbp), %eax
subl $0x40, %eax
je 0xb778
jmp 0xb69e
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0xb6b5
jmp 0xb6a8
movl -0x1c(%rbp), %eax
subl $0x5d, %eax
je 0xb6e7
jmp 0xb77e
cmpl $0x64, -0x18(%rbp)
jl 0xb6c4
movb $0x0, -0x1(%rbp)
jmp 0xb79d
movq -0x10(%rbp), %rax
movb (%rax), %dl
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x1c081(%rip), %rax     # 0x27760
movb %dl, (%rax,%rcx)
jmp 0xb77e
cmpl $0x0, -0x18(%rbp)
jle 0xb709
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x1c060(%rip), %rax     # 0x27760
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
je 0xb712
movb $0x0, -0x1(%rbp)
jmp 0xb79d
jmp 0xb77e
cmpl $0x0, -0x18(%rbp)
jle 0xb736
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x1c033(%rip), %rax     # 0x27760
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
je 0xb73c
movb $0x0, -0x1(%rbp)
jmp 0xb79d
jmp 0xb77e
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x6280
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0xb761
movb $0x0, -0x1(%rbp)
jmp 0xb79d
jmp 0xb77e
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0xb776
movb $0x0, -0x1(%rbp)
jmp 0xb79d
jmp 0xb77e
movb $0x0, -0x1(%rbp)
jmp 0xb79d
jmp 0xb780
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb63a
cmpl $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: loopiter(ident*, identstack&, tagval const&)
void loopiter(ident *id, identstack &stack, const tagval &v)
{
    if(id->stack != &stack)
    {
        pusharg(*id, v, stack);
        id->flags &= ~IDF_UNKNOWN;
    }
    else
    {
        if(id->valtype == VAL_STR) delete[] id->val.s;
        cleancode(*id);
        id->setval(v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xba82
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4d10
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x38(%rax)
jmp 0xbabf
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xbaa9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbaa7
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0xbaa9
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setiter(ident&, int, identstack&)
static inline void setiter(ident &id, int i, identstack &stack)
{
    if(i)
    {
        if(id.valtype != VAL_INT)
        {
            if(id.valtype == VAL_STR) delete[] id.val.s;
            cleancode(id);
            id.valtype = VAL_INT;
        }
        id.val.i = i;
    }
    else
    {
        tagval zero;
        zero.setint(0);
        pusharg(id, zero, stack);
        id.flags &= ~IDF_UNKNOWN;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xbbda
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0xbbce
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xbbba
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbbb8
movq -0x30(%rbp), %rdi
callq 0x1b110
jmp 0xbbba
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0xbc03
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x160b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x4d10
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: loopconc(ident*, int, unsigned int*, bool)
char *loopconc(ident *id, int n, uint *body, bool space)
{
    identstack stack;
    vector<char> s;
    loopi(n)
    {
        setiter(*id, i, stack);
        tagval v;
        executeret(body, v);
        const char *vstr = v.getstr();
        int len = strlen(vstr);
        if(space && i) s.add(' ');
        s.put(vstr, len);
        freearg(v);
    }
    if(n > 0) poparg(*id);
    s.add('\0');
    return newstring(s.getbuf(), s.length()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x43a0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xbdab
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0xbb70
jmp 0xbd0b
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4b60
jmp 0xbd1a
leaq -0x70(%rbp), %rdi
callq 0x16130
movq %rax, -0x88(%rbp)
jmp 0xbd2c
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x20b0
movl %eax, -0x7c(%rbp)
testb $0x1, -0x19(%rbp)
je 0xbd7e
cmpl $0x0, -0x4c(%rbp)
je 0xbd7e
movb $0x20, -0x7d(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x7d(%rbp), %rsi
callq 0x15fc0
jmp 0xbd62
jmp 0xbd7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x43d0
jmp 0xbe2d
movq -0x78(%rbp), %rsi
movl -0x7c(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x16020
jmp 0xbd90
leaq -0x70(%rbp), %rdi
callq 0x4500
jmp 0xbd9b
jmp 0xbd9d
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xbced
cmpl $0x0, -0xc(%rbp)
jle 0xbdbe
movq -0x8(%rbp), %rdi
callq 0x4d80
jmp 0xbdbc
jmp 0xbdbe
movb $0x0, -0x7e(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x7e(%rbp), %rsi
callq 0x15fc0
jmp 0xbdd1
leaq -0x48(%rbp), %rdi
callq 0x16070
movq %rax, -0x90(%rbp)
jmp 0xbde3
leaq -0x48(%rbp), %rdi
callq 0x16190
movl %eax, -0x94(%rbp)
jmp 0xbdf4
movq -0x90(%rbp), %rdi
movl -0x94(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x16150
movq %rax, -0xa0(%rbp)
jmp 0xbe14
leaq -0x48(%rbp), %rdi
callq 0x43d0
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: format(tagval*, int)
void format(tagval *args, int numargs)
{
    vector<char> s;
    const char *f = args[0].getstr();
    while(*f)
    {
        int c = *f++;
        if(c == '%')
        {
            int i = *f++;
            if(i >= '1' && i <= '9')
            {
                i -= '0';
                const char *sub = i < numargs ? args[i].getstr() : "";
                while(*sub) s.add(*sub++);
            }
            else s.add(i);
        }
        else s.add(c);
    }
    s.add('\0');
    result(s.getbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
callq 0x16130
movq %rax, -0x58(%rbp)
jmp 0xc017
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc130
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x25, -0x38(%rbp)
jne 0xc114
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x31, -0x3c(%rbp)
jl 0xc0fb
cmpl $0x39, -0x3c(%rbp)
jg 0xc0fb
movl -0x3c(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc0a9
movq -0x8(%rbp), %rdi
movslq -0x3c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x16130
movq %rax, -0x60(%rbp)
jmp 0xc09f
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xc0b6
leaq 0x122cf(%rip), %rax     # 0x1e37f
movq %rax, -0x68(%rbp)
jmp 0xc0b6
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc0f9
movq -0x48(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15fc0
jmp 0xc0e0
jmp 0xc0be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43d0
jmp 0xc16c
jmp 0xc112
movb -0x3c(%rbp), %al
movb %al, -0x49(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x49(%rbp), %rsi
callq 0x15fc0
jmp 0xc110
jmp 0xc112
jmp 0xc12b
movb -0x38(%rbp), %al
movb %al, -0x4a(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4a(%rbp), %rsi
callq 0x15fc0
jmp 0xc129
jmp 0xc12b
jmp 0xc01f
movb $0x0, -0x4b(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4b(%rbp), %rsi
callq 0x15fc0
jmp 0xc143
leaq -0x20(%rbp), %rdi
callq 0x16070
movq %rax, -0x70(%rbp)
jmp 0xc152
movq -0x70(%rbp), %rdi
callq 0x5ca0
jmp 0xc15d
leaq -0x20(%rbp), %rdi
callq 0x43d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: at(tagval*, int)
void at(tagval *args, int numargs)
{
    if(!numargs) return;
    const char *start = args[0].getstr(), *end = start + strlen(start);
    for(int i = 1; i < numargs; i++)
    {
        const char *list = start;
        int pos = args[i].getint();
        for(; pos > 0; pos--) if(!parselist(list)) break; 
        if(pos > 0 || !parselist(list, start, end)) start = end = "";
    }
    commandret->setstr(newstring(start, end-start));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xc6da
jmp 0xc7f0
movq -0x8(%rbp), %rdi
callq 0x16130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc7c5
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x15f10
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xc776
leaq -0x30(%rbp), %rdi
leaq 0x1b4b7(%rip), %rsi     # 0x27c00
leaq 0x1b4b8(%rip), %rdx     # 0x27c08
leaq 0x1b499(%rip), %rcx     # 0x27bf0
leaq 0x1b49a(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xc769
jmp 0xc776
jmp 0xc76b
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc738
cmpl $0x0, -0x34(%rbp)
jg 0xc79f
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq 0x1b461(%rip), %rcx     # 0x27bf0
leaq 0x1b462(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xc7b5
leaq 0x11bd9(%rip), %rax     # 0x1e37f
movq %rax, -0x20(%rbp)
leaq 0x11bce(%rip), %rax     # 0x1e37f
movq %rax, -0x18(%rbp)
jmp 0xc7b7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc70d
movq 0x1aa64(%rip), %rax     # 0x27230
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x16150
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x15b80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: sublist(char const*, int*, int*, int*)
void sublist(const char *s, int *skip, int *count, int *numargs)
{
    int offset = max(*skip, 0), len = *numargs >= 3 ? max(*count, 0) : -1;
    loopi(offset) if(!parselist(s)) break;
    if(len < 0) { if(offset > 0) skiplist(s); commandret->setstr(newstring(s)); return; }
    const char *list = s, *start, *end, *qstart, *qend = s;
    if(len > 0 && parselist(s, start, end, list, qend)) while(--len > 0 && parselist(s, start, end, qstart, qend));
    commandret->setstr(newstring(list, qend - list)); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
callq 0xca20
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jl 0xc8e6
movq -0x18(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
callq 0xca20
movl %eax, -0x5c(%rbp)
jmp 0xc8f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x5c(%rbp)
jmp 0xc8f0
movl -0x5c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xc93d
leaq -0x8(%rbp), %rdi
leaq 0x1b2f0(%rip), %rsi     # 0x27c00
leaq 0x1b2f1(%rip), %rdx     # 0x27c08
leaq 0x1b2d2(%rip), %rcx     # 0x27bf0
leaq 0x1b2d3(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xc930
jmp 0xc93d
jmp 0xc932
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc8fd
cmpl $0x0, -0x28(%rbp)
jge 0xc977
cmpl $0x0, -0x24(%rbp)
jle 0xc952
leaq -0x8(%rbp), %rdi
callq 0xca50
movq 0x1a8d7(%rip), %rax     # 0x27230
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15990
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x15b80
jmp 0xca15
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0xc9ea
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x58(%rbp), %r8
callq 0xc210
testb $0x1, %al
jne 0xc9ac
jmp 0xc9ea
jmp 0xc9ae
movl -0x28(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x69(%rbp)
jle 0xc9dd
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq -0x58(%rbp), %r8
callq 0xc210
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xc9e6
jmp 0xc9e8
jmp 0xc9ae
jmp 0xc9ea
movq 0x1a83f(%rip), %rax     # 0x27230
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
callq 0x16150
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x15b80
addq $0x80, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: skiplist(char const*&)
static inline void skiplist(const char *&p)
{
    for(;;)
    {
        p += strspn(p, " \t\r\n");
        if(p[0]!='/' || p[1]!='/') break;
        p += strcspn(p, "\n\0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x11911(%rip), %rsi     # 0x1e37b
callq 0x20a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xca9b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xca9d
jmp 0xcabf
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x112fe(%rip), %rsi     # 0x1dda9
callq 0x2040
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xca5c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: listfind(ident*, char const*, unsigned int const*)
void listfind(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) { intret(-1); return; }
    identstack stack;
    int n = -1;
    for(const char *s = list, *start, *end; parselist(s, start, end);)
    {
        ++n;
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);
        if(executebool(body)) { intret(n); goto found; }
    }
    intret(-1);
found:
    if(n >= 0) poparg(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xcb4c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5a70
jmp 0xcbe6
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq 0x1b082(%rip), %rcx     # 0x27bf0
leaq 0x1b083(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xcb80
jmp 0xcbcd
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rax, %rsi
callq 0x16150
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xcbf0
movq -0x18(%rbp), %rdi
callq 0xb030
testb $0x1, %al
jne 0xcbc1
jmp 0xcbcb
movl -0x34(%rbp), %edi
callq 0x5a70
jmp 0xcbd7
jmp 0xcb5b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5a70
cmpl $0x0, -0x34(%rbp)
jl 0xcbe6
movq -0x8(%rbp), %rdi
callq 0x4d80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setiter(ident&, char*, identstack&)
static inline void setiter(ident &id, char *val, identstack &stack)
{
    if(id.stack == &stack)
    {
        if(id.valtype == VAL_STR) delete[] id.val.s;
        else id.valtype = VAL_STR;
        cleancode(id);
        id.val.s = val;
    }
    else
    {
        tagval t;
        t.setstr(val);
        pusharg(id, t, stack);
        id.flags &= ~IDF_UNKNOWN;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xcc5b
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xcc39
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xcc37
movq -0x30(%rbp), %rdi
callq 0x1b110
jmp 0xcc44
movq -0x8(%rbp), %rax
movl $0x3, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xcc86
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x15b80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x4d10
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: looplist(ident*, char const*, unsigned int const*)
void looplist(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    int n = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);
        execute(body);
    }
    if(n) poparg(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xccb2
jmp 0xcd32
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq 0x1af1c(%rip), %rcx     # 0x27bf0
leaq 0x1af1d(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xcce6
jmp 0xcd23
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rax
subq %rax, %rsi
callq 0x16150
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xcbf0
movq -0x18(%rbp), %rdi
callq 0xaf00
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xccc1
cmpl $0x0, -0x34(%rbp)
je 0xcd32
movq -0x8(%rbp), %rdi
callq 0x4d80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: looplistconc(ident*, char const*, unsigned int const*, bool)
void looplistconc(ident *id, const char *list, const uint *body, bool space)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    vector<char> r;
    int n = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);

        if(n && space) r.add(' ');

        tagval v;
        executeret(body, v);
        const char *vstr = v.getstr();
        int len = strlen(vstr);
        r.put(vstr, len);
        freearg(v);
    }
    if(n) poparg(*id);
    r.add('\0');
    commandret->setstr(newstring(r.getbuf(), r.length()-1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xcd6c
jmp 0xcf4a
leaq -0x48(%rbp), %rdi
callq 0x43a0
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x1ae65(%rip), %rcx     # 0x27bf0
leaq 0x1ae66(%rip), %r8      # 0x27bf8
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xc210
movb %al, -0xa6(%rbp)
jmp 0xcdab
movb -0xa6(%rbp), %al
testb $0x1, %al
jne 0xcdba
jmp 0xceaf
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
subq %rdi, %rsi
callq 0x16150
movq %rax, -0xb0(%rbp)
jmp 0xcdd3
movq -0xb0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xcbf0
jmp 0xcdf1
cmpl $0x0, -0x4c(%rbp)
je 0xce32
testb $0x1, -0x19(%rbp)
je 0xce32
movb $0x20, -0x81(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x81(%rbp), %rsi
callq 0x15fc0
jmp 0xce16
jmp 0xce32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x43d0
jmp 0xcf53
movq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4b60
jmp 0xce44
leaq -0x98(%rbp), %rdi
callq 0x16130
movq %rax, -0xb8(%rbp)
jmp 0xce59
movq -0xb8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x20b0
movl %eax, -0xa4(%rbp)
movq -0xa0(%rbp), %rsi
movl -0xa4(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x16020
jmp 0xce91
leaq -0x98(%rbp), %rdi
callq 0x4500
jmp 0xce9f
jmp 0xcea1
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xcd84
cmpl $0x0, -0x4c(%rbp)
je 0xcec2
movq -0x8(%rbp), %rdi
callq 0x4d80
jmp 0xcec0
jmp 0xcec2
movb $0x0, -0xa5(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0xa5(%rbp), %rsi
callq 0x15fc0
jmp 0xcedb
movq 0x1a34e(%rip), %rax     # 0x27230
movq %rax, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x16070
movq %rax, -0xc0(%rbp)
jmp 0xcefb
leaq -0x48(%rbp), %rdi
callq 0x16190
movl %eax, -0xcc(%rbp)
jmp 0xcf0c
movq -0xc0(%rbp), %rdi
movl -0xcc(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x16150
movq %rax, -0xd8(%rbp)
jmp 0xcf2c
movq -0xd8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0x15b80
jmp 0xcf41
leaq -0x48(%rbp), %rdi
callq 0x43d0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x23e0
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: listfilter(ident*, char const*, unsigned int const*)
void listfilter(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    vector<char> r;
    int n = 0;
    for(const char *s = list, *start, *end, *quotestart, *quoteend; parselist(s, start, end, quotestart, quoteend); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);

        if(executebool(body))
        {
            if(r.length()) r.add(' ');
            r.put(quotestart, quoteend-quotestart);
        }
    }
    if(n) poparg(*id);
    r.add('\0');
    commandret->setstr(newstring(r.getbuf(), r.length()-1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xcfe5
jmp 0xd19b
leaq -0x40(%rbp), %rdi
callq 0x43a0
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x70(%rbp), %r8
callq 0xc210
movb %al, -0x8b(%rbp)
jmp 0xd01e
movb -0x8b(%rbp), %al
testb $0x1, %al
jne 0xd02d
jmp 0xd100
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x16150
movq %rax, -0x98(%rbp)
jmp 0xd046
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xcbf0
jmp 0xd06a
movq -0x18(%rbp), %rdi
callq 0xb030
movb %al, -0x99(%rbp)
jmp 0xd07b
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xd087
jmp 0xd0f0
leaq -0x40(%rbp), %rdi
callq 0x16190
movl %eax, -0xa0(%rbp)
jmp 0xd098
movl -0xa0(%rbp), %eax
cmpl $0x0, %eax
je 0xd0d8
movb $0x20, -0x89(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x89(%rbp), %rsi
callq 0x15fc0
jmp 0xd0bc
jmp 0xd0d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x43d0
jmp 0xd1a4
movq -0x68(%rbp), %rsi
movl -0x70(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x40(%rbp), %rdi
callq 0x16020
jmp 0xd0ee
jmp 0xd0f0
jmp 0xd0f2
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xcffd
cmpl $0x0, -0x44(%rbp)
je 0xd113
movq -0x8(%rbp), %rdi
callq 0x4d80
jmp 0xd111
jmp 0xd113
movb $0x0, -0x8a(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x8a(%rbp), %rsi
callq 0x15fc0
jmp 0xd12c
movq 0x1a0fd(%rip), %rax     # 0x27230
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16070
movq %rax, -0xa8(%rbp)
jmp 0xd14c
leaq -0x40(%rbp), %rdi
callq 0x16190
movl %eax, -0xb4(%rbp)
jmp 0xd15d
movq -0xa8(%rbp), %rdi
movl -0xb4(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x16150
movq %rax, -0xc0(%rbp)
jmp 0xd17d
movq -0xc0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x15b80
jmp 0xd192
leaq -0x40(%rbp), %rdi
callq 0x43d0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x23e0
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: prettylist(char const*, char const*)
void prettylist(const char *s, const char *conj)
{
    vector<char> p;
    const char *start, *end;
    for(int len = listlen(s), n = 0; parselist(s, start, end); n++)
    {
        p.put(start, end - start);
        if(n+1 < len)
        {
            if(len > 2 || !conj[0]) p.add(',');
            if(n+2 == len && conj[0])
            {
                p.add(' ');
                p.put(conj, strlen(conj));
            }
            p.add(' ');
        }
    } 
    p.add('\0');
    result(p.getbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
callq 0xc630
movl %eax, -0x50(%rbp)
jmp 0xd1d7
movl -0x50(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x48(%rbp)
leaq 0x1aa05(%rip), %rcx     # 0x27bf0
leaq 0x1aa06(%rip), %r8      # 0x27bf8
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc210
movb %al, -0x51(%rbp)
jmp 0xd208
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xd214
jmp 0xd2e3
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x20(%rbp), %rdi
callq 0x16020
jmp 0xd22a
movl -0x48(%rbp), %eax
addl $0x1, %eax
cmpl -0x34(%rbp), %eax
jge 0xd2d3
cmpl $0x2, -0x34(%rbp)
jg 0xd248
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd277
movb $0x2c, -0x49(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x49(%rbp), %rsi
callq 0x15fc0
jmp 0xd25b
jmp 0xd277
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43d0
jmp 0xd31f
movl -0x48(%rbp), %eax
addl $0x2, %eax
cmpl -0x34(%rbp), %eax
jne 0xd2be
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xd2be
movb $0x20, -0x4a(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4a(%rbp), %rsi
callq 0x15fc0
jmp 0xd29e
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x20b0
movq -0x60(%rbp), %rsi
movl %eax, %edx
leaq -0x20(%rbp), %rdi
callq 0x16020
jmp 0xd2bc
jmp 0xd2be
movb $0x20, -0x4b(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4b(%rbp), %rsi
callq 0x15fc0
jmp 0xd2d1
jmp 0xd2d3
jmp 0xd2d5
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xd1e4
movb $0x0, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x15fc0
jmp 0xd2f6
leaq -0x20(%rbp), %rdi
callq 0x16070
movq %rax, -0x68(%rbp)
jmp 0xd305
movq -0x68(%rbp), %rdi
callq 0x5ca0
jmp 0xd310
leaq -0x20(%rbp), %rdi
callq 0x43d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23e0
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: listincludes(char const*, char const*, int)
int listincludes(const char *list, const char *needle, int needlelen)
{
    int offset = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end);)
    {
        int len = end - start;
        if(needlelen == len && !strncmp(needle, start, len)) return offset;
        offset++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq 0x1a88b(%rip), %rcx     # 0x27bf0
leaq 0x1a88c(%rip), %r8      # 0x27bf8
callq 0xc210
testb $0x1, %al
jne 0xd377
jmp 0xd3b6
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jne 0xd3ab
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
callq 0x20d0
cmpl $0x0, %eax
jne 0xd3ab
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd3bd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd352
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: listdel(char const*, char const*)
char *listdel(const char *s, const char *del)
{
    vector<char> p;
    for(const char *start, *end, *qstart, *qend; parselist(s, start, end, qstart, qend);)
    {
        if(listincludes(del, start, end-start) < 0)
        {
            if(!p.empty()) p.add(' ');
            p.put(qstart, qend-qstart);
        }
    }
    p.add('\0');
    return newstring(p.getbuf(), p.length()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43a0
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xc210
movb %al, -0x4f(%rbp)
jmp 0xd457
movb -0x4f(%rbp), %al
testb $0x1, %al
jne 0xd463
jmp 0xd4e4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
callq 0xd330
movl %eax, -0x54(%rbp)
jmp 0xd47c
movl -0x54(%rbp), %eax
cmpl $0x0, %eax
jge 0xd4df
leaq -0x20(%rbp), %rdi
callq 0x16240
movb %al, -0x55(%rbp)
jmp 0xd492
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0xd4c7
jmp 0xd49b
movb $0x20, -0x4d(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4d(%rbp), %rsi
callq 0x15fc0
jmp 0xd4ae
jmp 0xd4c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43d0
jmp 0xd53e
movq -0x38(%rbp), %rsi
movl -0x40(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x20(%rbp), %rdi
callq 0x16020
jmp 0xd4dd
jmp 0xd4df
jmp 0xd439
movb $0x0, -0x4e(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x4e(%rbp), %rsi
callq 0x15fc0
jmp 0xd4f7
leaq -0x20(%rbp), %rdi
callq 0x16070
movq %rax, -0x60(%rbp)
jmp 0xd506
leaq -0x20(%rbp), %rdi
callq 0x16190
movl %eax, -0x64(%rbp)
jmp 0xd514
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x16150
movq %rax, -0x70(%rbp)
jmp 0xd52b
leaq -0x20(%rbp), %rdi
callq 0x43d0
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x23e0
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: strreplace(char const*, char const*, char const*)
char *strreplace(const char *s, const char *oldval, const char *newval)
{
    vector<char> buf;

    int oldlen = strlen(oldval);
    if(!oldlen) return newstring(s);
    for(;;)
    {
        const char *found = strstr(s, oldval);
        if(found)
        {
            while(s < found) buf.add(*s++);
            for(const char *n = newval; *n; n++) buf.add(*n);
            s = found + oldlen;
        }
        else
        {
            while(*s) buf.add(*s++);
            buf.add('\0');
            return newstring(buf.getbuf(), buf.length());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43a0
movq -0x18(%rbp), %rdi
callq 0x20b0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0xf6bf
movq -0x10(%rbp), %rdi
callq 0x15990
movq %rax, -0x68(%rbp)
jmp 0xf691
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xf7c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43d0
jmp 0xf7d8
jmp 0xf6c1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2050
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xf741
jmp 0xf6db
movq -0x10(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0xf700
movq -0x10(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15fc0
jmp 0xf6fe
jmp 0xf6db
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf730
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x15fc0
jmp 0xf720
jmp 0xf722
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xf708
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xf7bd
jmp 0xf743
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf767
movq -0x10(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15fc0
jmp 0xf765
jmp 0xf743
movb $0x0, -0x59(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x59(%rbp), %rsi
callq 0x15fc0
jmp 0xf77a
leaq -0x30(%rbp), %rdi
callq 0x16070
movq %rax, -0x70(%rbp)
jmp 0xf789
leaq -0x30(%rbp), %rdi
callq 0x16190
movl %eax, -0x74(%rbp)
jmp 0xf797
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
movslq %eax, %rsi
callq 0x16150
movq %rax, -0x80(%rbp)
jmp 0xf7ac
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xf7c2
jmp 0xf6c1
leaq -0x30(%rbp), %rdi
callq 0x43d0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: debugalias()
static void debugalias()
{
    if(!dbgalias) return;
    int total = 0, depth = 0;
    for(identlink *l = aliasstack; l != &noalias; l = l->next) total++;
    for(identlink *l = aliasstack; l != &noalias; l = l->next)
    {
        ident *id = l->id;
        ++depth;
        if(depth < dbgalias) conoutf(CON_ERROR, "  %d) %s", total-depth+1, id->name);
        else if(l->next == &noalias) conoutf(CON_ERROR, depth == dbgalias ? "  %d) %s" : "  ..%d) %s", total-depth+1, id->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x17e05(%rip)     # 0x276e4
jne 0xf8e6
jmp 0xf9e4
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x1793d(%rip), %rax     # 0x27238
movq %rax, -0x10(%rbp)
leaq 0x1793a(%rip), %rax     # 0x27240
cmpq %rax, -0x10(%rbp)
je 0xf923
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf8ff
movq 0x1790e(%rip), %rax     # 0x27238
movq %rax, -0x18(%rbp)
leaq 0x1790b(%rip), %rax     # 0x27240
cmpq %rax, -0x18(%rbp)
je 0xf9e4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x17d88(%rip), %eax     # 0x276e4
jge 0xf984
movl -0x4(%rbp), %edx
subl -0x8(%rbp), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x4, %edi
leaq 0xe919(%rip), %rsi      # 0x1e294
movb $0x0, %al
callq 0x4190
jmp 0xf9d1
movq -0x18(%rbp), %rax
leaq 0x178b1(%rip), %rcx     # 0x27240
cmpq %rcx, 0x8(%rax)
jne 0xf9cf
movl -0x8(%rbp), %ecx
movl 0x17d46(%rip), %edx     # 0x276e4
leaq 0xe8f8(%rip), %rsi      # 0x1e29d
leaq 0xe8e8(%rip), %rax      # 0x1e294
cmpl %edx, %ecx
cmoveq %rax, %rsi
movl -0x4(%rbp), %edx
subl -0x8(%rbp), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x4, %edi
movb $0x0, %al
callq 0x4190
jmp 0xf9d1
jmp 0xf9d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf92e
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setarg(ident&, tagval&)
static inline void setarg(ident &id, tagval &v)
{
    if(aliasstack->usedargs&(1<<id.index))
    {
        if(id.valtype == VAL_STR) delete[] id.val.s;
        id.setval(v);
        cleancode(id);
    }
    else
    {
        pusharg(id, v, aliasstack->argstack[id.index]);
        aliasstack->usedargs |= 1<<id.index;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x17831(%rip), %rax     # 0x27238
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xfa60
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xfa48
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xfa46
movq -0x18(%rbp), %rdi
callq 0x1b110
jmp 0xfa48
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16100
movq -0x8(%rbp), %rdi
callq 0x47b0
jmp 0xfaa4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x177c9(%rip), %rax     # 0x27238
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
callq 0x4d10
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x1779a(%rip), %rax     # 0x27238
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setalias(ident&, tagval&)
static inline void setalias(ident &id, tagval &v)
{
    if(id.valtype == VAL_STR) delete[] id.val.s;
    id.setval(v);
    cleancode(id);
    id.flags = (id.flags & identflags) | identflags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xfae7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xfae5
movq -0x18(%rbp), %rdi
callq 0x1b110
jmp 0xfae7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16100
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl 0x17bae(%rip), %ecx     # 0x276b8
orl 0x17ba8(%rip), %ecx     # 0x276b8
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/./command.h
// Function: getstr(identval const&, int)
static inline const char *getstr(const identval &v, int type) 
{
    switch(type)
    {
        case VAL_STR: case VAL_MACRO: return v.s;
        case VAL_INT: return intstr(v.i);
        case VAL_FLOAT: return floatstr(v.f);
        default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0xfb84
movq -0x20(%rbp), %rax
leaq 0xdae6(%rip), %rcx      # 0x1d630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xfb8f
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xb7b0
movq %rax, -0x8(%rbp)
jmp 0xfb8f
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
callq 0x5f70
movq %rax, -0x8(%rbp)
jmp 0xfb8f
leaq 0xe7f4(%rip), %rax      # 0x1e37f
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: skipcomments(char const*&)
static inline void skipcomments(const char *&p)
{
    for(;;)
    {
        p += strspn(p, " \t\r");
        if(p[0]!='/' || p[1]!='/') break;
        p += strcspn(p, "\n\0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xd9fb(%rip), %rsi      # 0x1e305
callq 0x20a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1093b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x1093d
jmp 0x1095f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xd45e(%rip), %rsi      # 0x1dda9
callq 0x2040
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x108fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)