LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compileword(vector<unsigned int>&, char const*&, int, char*&, int&)
static bool compileword(vector<uint> &code, const char *&p, int wordtype, char *&word, int &wordlen)
{
    skipcomments(p);
    switch(*p)
    {
        case '\"': word = cutstring(p, wordlen); break;
        case '$': compilelookup(code, p, wordtype); return true;
        case '(':
            p++;
            code.add(CODE_ENTER);
            compilestatements(code, p, VAL_ANY, ')');
            code.add(CODE_EXIT|(wordtype < VAL_ANY ? wordtype<<CODE_RET : 0));
            switch(wordtype)
            {
                case VAL_CODE: code.add(CODE_COMPILE); break;
                case VAL_IDENT: code.add(CODE_IDENTU); break;
            }
            return true;        
        case '[':
            p++;
            compileblock(code, p, wordtype);
            return true;
        default: word = cutword(p, wordlen); break;
    }
    return word!=NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x108f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x22, %eax
je 0x109cd
jmp 0x109a8
movl -0x44(%rbp), %eax
subl $0x24, %eax
je 0x109e9
jmp 0x109b2
movl -0x44(%rbp), %eax
subl $0x28, %eax
je 0x10a02
jmp 0x109bc
movl -0x44(%rbp), %eax
subl $0x5b, %eax
je 0x10ab8
jmp 0x10adc
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x10af3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x110f0
movb $0x1, -0x1(%rbp)
jmp 0x10b03
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x3, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x16f60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
movl $0x29, %ecx
callq 0xfba0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x10a54
movl -0x1c(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x54(%rbp)
jmp 0x10a5b
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x10a5b
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x16f60
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
subl $0x5, %eax
je 0x10a88
jmp 0x10a7e
movl -0x58(%rbp), %eax
subl $0x7, %eax
je 0x10a9e
jmp 0x10ab2
movq -0x10(%rbp), %rdi
movl $0xa, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x16f60
jmp 0x10ab2
movq -0x10(%rbp), %rdi
movl $0xe, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x16f60
movb $0x1, -0x1(%rbp)
jmp 0x10b03
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x116b0
movb $0x1, -0x1(%rbp)
jmp 0x10b03
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11c70
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compilestr(vector<unsigned int>&, char const*, int, bool)
static inline void compilestr(vector<uint> &code, const char *word, int len, bool macro = false)
{
    if(len <= 3 && !macro)
    {
        uint op = CODE_VALI|RET_STR;
        for(int i = 0; i < len; i++) op |= uint(uchar(word[i]))<<((i+1)*8);
        code.add(op);
        return;
    }
    code.add((macro ? CODE_MACRO : CODE_VAL|RET_STR)|(len<<8));
    code.put((const uint *)word, len/sizeof(uint));
    size_t endlen = len%sizeof(uint);
    union
    {
        char c[sizeof(uint)];
        uint u;
    } end;
    end.u = 0;
    memcpy(end.c, word + len - endlen, endlen);
    code.add(end.u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0x10b86
testb $0x1, -0x15(%rbp)
jne 0x10b86
movl $0xc6, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x10b74
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
shll $0x3, %ecx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x10b44
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x16f60
jmp 0x10c09
movq -0x8(%rbp), %rdi
movb -0x15(%rbp), %dl
movl $0xc5, %eax
movl $0x7, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edx
callq 0x170f0
movslq -0x14(%rbp), %rax
andq $0x3, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x34(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
subq -0x30(%rbp), %rax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x2170
movq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x16f60
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compilearg(vector<unsigned int>&, char const*&, int)
static inline bool compilearg(vector<uint> &code, const char *&p, int wordtype)
{
    char *word = NULL;
    int wordlen = 0;
    bool more = compileword(code, p, wordtype, word, wordlen);
    if(!more) return false;
    if(word) 
    {
        compileval(code, wordtype, word, wordlen);
        delete[] word;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x10970
andb $0x1, %al
movb %al, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0x10c5b
movb $0x0, -0x1(%rbp)
jmp 0x10c92
cmpq $0x0, -0x28(%rbp)
je 0x10c8e
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x11cf0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x10c8c
movq -0x38(%rbp), %rdi
callq 0x1b110
jmp 0x10c8e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compileint(vector<unsigned int>&, int)
static inline void compileint(vector<uint> &code, int i)
{
    if(i >= -0x800000 && i <= 0x7FFFFF)
        code.add(CODE_VALI|RET_INT|(i<<8));
    else
    {
        code.add(CODE_VAL|RET_INT);
        code.add(i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xff800000, -0xc(%rbp) # imm = 0xFF800000
jl 0x10d3c
cmpl $0x7fffff, -0xc(%rbp)   # imm = 0x7FFFFF
jg 0x10d3c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x8, %eax
orl $0x46, %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x16f60
jmp 0x10d63
movq -0x8(%rbp), %rdi
movl $0x45, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x16f60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compileblock(vector<unsigned int>&)
static inline void compileblock(vector<uint> &code)
{
    int start = code.length();
    code.add(CODE_BLOCK);
    code.add(CODE_OFFSET|((start+2)<<8));
    code.add(CODE_EXIT);
    code[start] |= uint(code.length() - (start + 1))<<8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15e00
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x2, %eax
shll $0x8, %eax
orl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
movl $0x4, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
callq 0x15e00
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x15ea0
movl -0x1c(%rbp), %ecx
orl (%rax), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: debugcodeline(char const*, char const*, ...)
static void debugcodeline(const char *p, const char *fmt, ...)
{
    if(nodebug) return;

    va_list args;
    va_start(args, fmt);
    conoutfv(CON_ERROR, debugline(p, fmt), args);
    va_end(args);

    debugalias();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x10fb8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x16709(%rip)     # 0x276ec
je 0x10fe7
jmp 0x11032
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12600
movq %rax, %rsi
leaq -0x30(%rbp), %rdx
movl $0x4, %edi
callq 0x40c0
leaq -0x30(%rbp), %rax
callq 0xf8d0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: cutstring(char const*&, int&)
static inline char *cutstring(const char *&p, int &len)
{
    p++;
    const char *end = parsestring(p);
    char *s = newstring(end - p);         
    len = unescapestring(s, p, end);
    s[len] = '\0';
    p = end;
    if(*p=='\"') p++;
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdi
callq 0x16090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x6310
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x110d8
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: cutword(char const*&, int&)
static inline char *cutword(const char *&p, int &len)
{
    const char *word = p;
    p = parseword(p);
    len = p-word;
    if(!len) return NULL;
    return newstring(word, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11cca
movq $0x0, -0x8(%rbp)
jmp 0x11cde
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x16150
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compileval(vector<unsigned int>&, int, char*, int)
static inline void compileval(vector<uint> &code, int wordtype, char *word, int wordlen)
{
    switch(wordtype)
    {
        case VAL_STR: compilestr(code, word, wordlen, true); break;
        case VAL_ANY: compilestr(code, word, wordlen); break;
        case VAL_FLOAT: compilefloat(code, word); break;
        case VAL_INT: compileint(code, word); break;
        case VAL_CODE: 
        {
            int start = code.length();
            code.add(CODE_BLOCK);
            code.add(CODE_OFFSET|((start+2)<<8));
            const char *p = word;
            compilestatements(code, p, VAL_ANY);
            code.add(CODE_EXIT|RET_STR);
            code[start] |= uint(code.length() - (start + 1))<<8;
            break;
        }
        case VAL_IDENT: compileident(code, word); break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x6, %eax
ja 0x11e2a
movq -0x40(%rbp), %rax
leaq 0xbbf7(%rip), %rcx      # 0x1d91c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl $0x1, %ecx
callq 0x10b10
jmp 0x11e2c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0x10b10
jmp 0x11e2c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10dc0
jmp 0x11e2c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10d70
jmp 0x11e2c
movq -0x8(%rbp), %rdi
callq 0x15e00
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x2, %eax
shll $0x8, %eax
orl $0x1, %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x16f60
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0xfba0
movq -0x8(%rbp), %rdi
movl $0xc4, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
callq 0x15e00
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
shll $0x8, %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x15ea0
movl -0x44(%rbp), %ecx
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x11e2c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10ed0
jmp 0x11e2c
jmp 0x11e2c
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: parseword(char const*)
static inline const char *parseword(const char *p)
{
    const int maxbrak = 100;
    static char brakstack[maxbrak];
    int brakdepth = 0;
    for(;; p++)
    {
        p += strcspn(p, "\"/;()[] \t\r\n\0");
        switch(p[0])
        {
            case '"': case ';': case ' ': case '\t': case '\r': case '\n': case '\0': return p;
            case '/': if(p[1] == '/') return p; break;
            case '[': case '(': if(brakdepth >= maxbrak) return p; brakstack[brakdepth++] = p[0]; break;
            case ']': if(brakdepth <= 0 || brakstack[--brakdepth] != '[') return p; break;
            case ')': if(brakdepth <= 0 || brakstack[--brakdepth] != '(') return p; break;
        }
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x64, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xba25(%rip), %rsi      # 0x1ddba
callq 0x2040
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5d, %eax
ja 0x1248d
movq -0x20(%rbp), %rax
leaq 0xb583(%rip), %rcx      # 0x1d94c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x124a0
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x123f9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x124a0
jmp 0x1248d
cmpl $0x64, -0x18(%rbp)
jl 0x12411
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x124a0
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 0x15854(%rip), %rax     # 0x27c80
movb %dl, (%rax,%rcx)
jmp 0x1248d
cmpl $0x0, -0x18(%rbp)
jle 0x12453
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x15836(%rip), %rax     # 0x27c80
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
je 0x1245d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x124a0
jmp 0x1248d
cmpl $0x0, -0x18(%rbp)
jle 0x12481
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rcx
leaq 0x15808(%rip), %rax     # 0x27c80
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
je 0x1248b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x124a0
jmp 0x1248d
jmp 0x1248f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1238a
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compilefloat(vector<unsigned int>&, float)
static inline void compilefloat(vector<uint> &code, float f)
{
    if(int(f) == f && f >= -0x800000 && f <= 0x7FFFFF)
        code.add(CODE_VALI|RET_FLOAT|(int(f)<<8));
    else
    {
        union { float f; uint u; } conv;
        conv.f = f;
        code.add(CODE_VAL|RET_FLOAT);
        code.add(conv.u);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
cvttss2si -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm0
ucomiss -0xc(%rbp), %xmm0
jne 0x12541
jp 0x12541
movss -0xc(%rbp), %xmm0
movss 0xb8c5(%rip), %xmm1     # 0x1ddd4
ucomiss %xmm1, %xmm0
jb 0x12541
movss 0xb8bc(%rip), %xmm0     # 0x1ddd8
ucomiss -0xc(%rbp), %xmm0
jb 0x12541
movq -0x8(%rbp), %rdi
cvttss2si -0xc(%rbp), %eax
shll $0x8, %eax
orl $0x86, %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x16f60
jmp 0x1256c
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x85, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x16f60
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x16f60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: debugline(char const*, char const*)
static const char *debugline(const char *p, const char *fmt)
{
    if(!sourcestr) return fmt;
    int num = 1;
    const char *line = sourcestr;
    for(;;)
    {
        const char *end = strchr(line, '\n');
        if(!end) end = line + strlen(line);
        if(p >= line && p <= end)
        {
            static string buf;
            if(sourcefile) formatstring(buf)("%s:%d: %s", sourcefile, num, fmt);
            else formatstring(buf)("%d: %s", num, fmt);
            return buf;
        }
        if(!*end) break;
        line = end + 1;
        num++;
    }
    return fmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, 0x150f0(%rip)     # 0x27708
jne 0x12627
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12724
movl $0x1, -0x1c(%rbp)
movq 0x150d3(%rip), %rax     # 0x27708
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0xa, %esi
callq 0x2080
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x12671
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x126f7
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x126f7
cmpq $0x0, 0x15073(%rip)     # 0x27700
je 0x126c1
leaq -0x38(%rbp), %rdi
leaq 0x15656(%rip), %rsi     # 0x27cf0
callq 0x167a0
movq 0x1505a(%rip), %rdx     # 0x27700
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq -0x38(%rbp), %rdi
leaq 0xbc69(%rip), %rsi      # 0x1e321
movb $0x0, %al
callq 0x167c0
jmp 0x126ea
leaq -0x40(%rbp), %rdi
leaq 0x15624(%rip), %rsi     # 0x27cf0
callq 0x167a0
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq 0xbc41(%rip), %rsi      # 0x1e324
movb $0x0, %al
callq 0x167c0
leaq 0x155ff(%rip), %rax     # 0x27cf0
movq %rax, -0x8(%rbp)
jmp 0x12724
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x12702
jmp 0x1271c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12639
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: skipcode(unsigned int const*, tagval&)
static const uint *skipcode(const uint *code, tagval &result)
{
    int depth = 0;
    for(;;)
    {
        uint op = *code++;
        switch(op&0xFF)
        {
            case CODE_MACRO:
            case CODE_VAL|RET_STR:
            {
                uint len = op>>8;
                code += len/sizeof(uint) + 1;
                continue;
            }
            case CODE_BLOCK:
            {
                uint len = op>>8;
                code += len;
                continue;
            }
            case CODE_ENTER:
                ++depth;
                continue;
            case CODE_EXIT|RET_NULL: case CODE_EXIT|RET_STR: case CODE_EXIT|RET_INT: case CODE_EXIT|RET_FLOAT:
                if(depth <= 0)
                {
                    forcearg(result, op&CODE_RET_MASK);
                    return code;
                }
                --depth;
                continue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movzbl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x12808
jmp 0x1276d
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0x12816
jmp 0x1277b
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x127c1
jmp 0x12785
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x127e6
jmp 0x1278f
movl -0x24(%rbp), %eax
subl $0x44, %eax
je 0x12816
jmp 0x12799
movl -0x24(%rbp), %eax
subl $0x84, %eax
je 0x12816
jmp 0x127a5
movl -0x24(%rbp), %eax
subl $0xc4, %eax
je 0x12816
jmp 0x127b1
movl -0x24(%rbp), %eax
subl $0xc5, %eax
jne 0x12846
jmp 0x127c1
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrq $0x2, %rax
addq $0x1, %rax
shlq $0x2, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12747
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x12747
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12747
cmpl $0x0, -0x14(%rbp)
jg 0x12838
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
andl $0xc0, %esi
callq 0x12850
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12747
jmp 0x12747
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forcearg(tagval&, int)
static inline void forcearg(tagval &v, int type)
{
    switch(type)
    {
        case RET_STR: if(v.type != VAL_STR) forcestr(v); break;
        case RET_INT: if(v.type != VAL_INT) forceint(v); break;
        case RET_FLOAT: if(v.type != VAL_FLOAT) forcefloat(v); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x40, %eax
je 0x12899
jmp 0x1286c
movl -0x10(%rbp), %eax
subl $0x80, %eax
je 0x128ae
jmp 0x12878
movl -0x10(%rbp), %eax
subl $0xc0, %eax
jne 0x128c3
jmp 0x12884
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0x12897
movq -0x8(%rbp), %rdi
callq 0xae00
jmp 0x128c3
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x128ac
movq -0x8(%rbp), %rdi
callq 0x12950
jmp 0x128c3
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x128c1
movq -0x8(%rbp), %rdi
callq 0x129f0
jmp 0x128c3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forceint(tagval&)
static inline int forceint(tagval &v)
{
    int i = 0;
    switch(v.type)
    {
        case VAL_FLOAT: i = v.f; break;
        case VAL_STR: i = parseint(v.s); break;
        case VAL_MACRO: i = parseint(v.s); break;
        case VAL_INT: return v.i;
    }
    freearg(v);
    v.setint(i);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x129c5
movq -0x20(%rbp), %rax
leaq 0xb142(%rip), %rcx      # 0x1dac4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cvttss2si (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x129c5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x124b0
movl %eax, -0x14(%rbp)
jmp 0x129c5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x124b0
movl %eax, -0x14(%rbp)
jmp 0x129c5
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x129e0
movq -0x10(%rbp), %rdi
callq 0x4500
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x160b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forcefloat(tagval&)
static inline float forcefloat(tagval &v)
{
    float f = 0.0f;
    switch(v.type)
    {
        case VAL_INT: f = v.i; break;
        case VAL_STR: f = parsefloat(v.s); break;
        case VAL_MACRO: f = parsefloat(v.s); break;
        case VAL_FLOAT: return v.f;
    }
    freearg(v);
    v.setfloat(f);
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x12a6f
movq -0x20(%rbp), %rax
leaq 0xb0ba(%rip), %rcx      # 0x1dadc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12580
movss %xmm0, -0x14(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12580
movss %xmm0, -0x14(%rbp)
jmp 0x12a6f
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x12a90
movq -0x10(%rbp), %rdi
callq 0x4500
movq -0x10(%rbp), %rdi
movss -0x14(%rbp), %xmm0
callq 0x160d0
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forcenull(tagval&)
static inline void forcenull(tagval &v)
{
    switch(v.type)
    {
        case VAL_NULL: return;
    }
    freearg(v);
    v.setnull();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
testl %eax, %eax
jne 0x1474b
jmp 0x14749
jmp 0x1475d
movq -0x8(%rbp), %rdi
callq 0x4500
movq -0x8(%rbp), %rdi
callq 0x16780
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: conc(vector<char>&, tagval*, int, bool, char const*, int)
static char *conc(vector<char> &buf, tagval *v, int n, bool space, const char *prefix = NULL, int prefixlen = 0)
{
    if(prefix)
    {
        buf.put(prefix, prefixlen);
        if(space && n) buf.add(' ');
    }
    loopi(n)
    {
        const char *s = "";
        int len = 0;
        switch(v[i].type)
        {
            case VAL_INT: s = intstr(v[i].i); break;
            case VAL_FLOAT: s = floatstr(v[i].f); break;
            case VAL_STR: s = v[i].s; break;
            case VAL_MACRO: s = v[i].s; len = v[i].code[-1]>>8; goto haslen;
        }
        len = int(strlen(s));
    haslen:
        buf.put(s, len);
        if(i == n-1) break;
        if(space) buf.add(' ');
    }
    buf.add('\0');
    return buf.getbuf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x147c8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x16020
testb $0x1, -0x15(%rbp)
je 0x147c6
cmpl $0x0, -0x14(%rbp)
je 0x147c6
movq -0x8(%rbp), %rdi
movb $0x20, -0x25(%rbp)
leaq -0x25(%rbp), %rsi
callq 0x15fc0
jmp 0x147c8
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x148f9
leaq 0x9b9d(%rip), %rax      # 0x1e37f
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x5, %eax
ja 0x148a7
movq -0x48(%rbp), %rax
leaq 0x9453(%rip), %rcx      # 0x1dc6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0xb7b0
movq %rax, -0x38(%rbp)
jmp 0x148a7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
callq 0x5f70
movq %rax, -0x38(%rbp)
jmp 0x148a7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x148a7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x4(%rax), %eax
shrl $0x8, %eax
movl %eax, -0x3c(%rbp)
jmp 0x148b3
movq -0x38(%rbp), %rdi
callq 0x20b0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x16020
movl -0x2c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x148d2
jmp 0x148f9
testb $0x1, -0x15(%rbp)
je 0x148e9
movq -0x8(%rbp), %rdi
movb $0x20, -0x3d(%rbp)
leaq -0x3d(%rbp), %rsi
callq 0x15fc0
jmp 0x148eb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x147cf
movq -0x8(%rbp), %rdi
movb $0x0, -0x3e(%rbp)
leaq -0x3e(%rbp), %rsi
callq 0x15fc0
movq -0x8(%rbp), %rdi
callq 0x16070
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forceident(tagval&)
static inline ident *forceident(tagval &v)
{
    switch(v.type)
    {
        case VAL_IDENT: return v.id;
        case VAL_MACRO:
        {
            ident *id = newident(v.s, IDF_UNKNOWN);
            v.setident(id);
            return id;
        }
        case VAL_STR: 
        { 
            ident *id = newident(v.s, IDF_UNKNOWN); 
            delete[] v.s; 
            v.setident(id); 
            return id; 
        }
    }
    freearg(v);
    v.setident(dummyident);
    return dummyident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x14991
jmp 0x1493d
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x14965
jmp 0x14947
movl -0x24(%rbp), %eax
subl $0x7, %eax
jne 0x149d7
jmp 0x14955
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x149fb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4e50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x172c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x149fb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4e50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x149c0
movq -0x30(%rbp), %rdi
callq 0x1b110
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x172c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x149fb
movq -0x10(%rbp), %rdi
callq 0x4500
movq -0x10(%rbp), %rdi
movq 0x12cc5(%rip), %rsi     # 0x276b0
callq 0x172c0
movq 0x12cb9(%rip), %rax     # 0x276b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./command.h
// Function: getint(identval const&, int)
static inline int getint(const identval &v, int type)
{
    switch(type)
    {
        case VAL_INT: return v.i;
        case VAL_FLOAT: return int(v.f);
        case VAL_STR: case VAL_MACRO: return parseint(v.s); 
        default: return 0;
    }
}

// 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 0x14a6c
movq -0x20(%rbp), %rax
leaq 0x924a(%rip), %rcx      # 0x1dc84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x14a73
movq -0x10(%rbp), %rax
cvttss2si (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x14a73
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x124b0
movl %eax, -0x4(%rbp)
jmp 0x14a73
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/./command.h
// Function: getfloat(identval const&, int)
static inline float getfloat(const identval &v, int type)
{
    switch(type)
    {
        case VAL_FLOAT: return v.f;
        case VAL_INT: return float(v.i);
        case VAL_STR: case VAL_MACRO: return parsefloat(v.s);
        default: return 0.0f;
    }
}

// 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 0x14ae4
movq -0x20(%rbp), %rax
leaq 0x91f2(%rip), %rcx      # 0x1dc9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x14aec
movq -0x10(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x14aec
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12580
movss %xmm0, -0x4(%rbp)
jmp 0x14aec
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: getbool(char const*)
static inline bool getbool(const char *s)
{
    switch(s[0])
    {
        case '+': case '-': 
            switch(s[1])
            {
                case '0': break;
                case '.': return !isdigit(s[2]) || parsefloat(s) != 0;
                default: return true;
            }
            // fall through
        case '0':
        {
            char *end;
            int val = int(strtoul((char *)s, &end, 0));
            if(val) return true;
            switch(*end)
            {
                case 'e': case '.': return parsefloat(s) != 0;
                default: return false;
            }
        }
        case '.': return !isdigit(s[1]) || parsefloat(s) != 0;
        case '\0': return false;
        default: return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x30, %eax
ja 0x14c42
movq -0x28(%rbp), %rax
leaq 0x9187(%rip), %rcx      # 0x1dcb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x2e, %eax
je 0x14b54
jmp 0x14b48
movl -0x2c(%rbp), %eax
subl $0x30, %eax
jne 0x14b94
jmp 0x14b52
jmp 0x14b9d
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x21b0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2d(%rbp)
je 0x14b87
movq -0x10(%rbp), %rdi
callq 0x12580
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x14c46
movb $0x1, -0x1(%rbp)
jmp 0x14c46
jmp 0x14b9f
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x2070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x14bc0
movb $0x1, -0x1(%rbp)
jmp 0x14c46
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2e, %eax
je 0x14bdb
jmp 0x14bd1
movl -0x34(%rbp), %eax
subl $0x65, %eax
jne 0x14bf9
jmp 0x14bdb
movq -0x10(%rbp), %rdi
callq 0x12580
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x14c46
movb $0x0, -0x1(%rbp)
jmp 0x14c46
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x21b0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x35(%rbp)
je 0x14c32
movq -0x10(%rbp), %rdi
callq 0x12580
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x14c46
movb $0x0, -0x1(%rbp)
jmp 0x14c46
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: void insertionsort<sortitem, sortfun>(sortitem*, sortitem*, sortfun)
static inline void insertionsort(T *start, T *end, F fun)
{
    for(T *i = start+1; i < end; i++)
    {
        if(fun(*i, i[-1]))
        {
            T tmp = *i;
            *i = i[-1];
            T *j = i-1;
            for(; j > start && fun(tmp, j[-1]); --j)
                *j = j[-1];
            *j = tmp;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x15751
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $-0x18, %rdx
callq 0x17990
testb $0x1, %al
jne 0x15680
jmp 0x1573e
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x18(%rcx), %rdx
movq %rdx, (%rax)
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x41(%rbp)
jbe 0x156ed
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
addq $-0x18, %rdx
leaq -0x30(%rbp), %rsi
callq 0x17990
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x156f6
jmp 0x15723
movq -0x38(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x18(%rcx), %rdx
movq %rdx, (%rax)
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x38(%rbp)
jmp 0x156c6
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x15740
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x15654
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: hashset<ident>::hashset(int)
hashset(int size = 1<<10)
      : size(size)
    {
        numelems = 0;
        chunks = NULL;
        unused = NULL;
        chains = new chain *[size];
        loopi(size) chains[i] = NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1b0b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x157f1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x157ca
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: copystring(char*, char const*, unsigned long)
inline char *copystring(char *d, const char *s, size_t len = MAXSTRLEN)
{
    size_t slen = min(strlen(s)+1, len);
    memcpy(d, s, slen);
    d[slen-1] = 0;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x14c60
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2170
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: vector<char*>::removeunordered(int)
T removeunordered(int i)
    {
        T e = buf[i];
        ulen--;
        if(ulen>0) buf[i] = buf[ulen];
        return e;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x18(%rbp)
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0xc(%rax)
jle 0x1631b
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq 0xc(%rax), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: vector<ident>::growbuf(int)
void growbuf(int sz)
    {
        int olen = alen;
        if(!alen) alen = max(MINSIZE, sz);
        else while(alen < sz) alen *= 2;
        if(alen <= olen) return;
        uchar *newbuf = new uchar[alen*sizeof(T)];
        if(olen > 0)
        {
            memcpy(newbuf, (void *)buf, olen*sizeof(T));
            delete[] (uchar *)buf;
        }
        buf = (T *)newbuf;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x16bbb
movl -0xc(%rbp), %esi
movl $0x8, %edi
callq 0xca20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x16bd9
jmp 0x16bbd
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x16bd7
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
shll %ecx
movl %ecx, 0x8(%rax)
jmp 0x16bbd
jmp 0x16bd9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x10(%rbp), %eax
jg 0x16be7
jmp 0x16c41
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rdi
shlq $0x6, %rdi
callq 0x1b0b0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x16c36
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movslq -0x10(%rbp), %rdx
shlq $0x6, %rdx
callq 0x2170
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x16c34
movq -0x28(%rbp), %rdi
callq 0x1b110
jmp 0x16c36
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./tools.h
// Function: hashset<ident>::insert(unsigned int)
chain *insert(uint h)
    {
        if(!unused)
        {
            chainchunk *chunk = new chainchunk;
            chunk->next = chunks;
            chunks = chunk;
            loopi(CHUNKSIZE-1) chunk->chains[i].next = &chunk->chains[i+1];
            chunk->chains[CHUNKSIZE-1].next = unused;
            unused = chunk->chains;
        }
        chain *c = unused;
        unused = unused->next;
        c->next = chains[h];
        chains[h] = c;
        numelems++;
        return c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x16d25
movl $0x1208, %edi           # imm = 0x1208
callq 0x1b080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x16d80
jmp 0x16c8d
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x1200(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x3f, -0x28(%rbp)
jge 0x16d0a
movq -0x18(%rbp), %rcx
movl -0x28(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x48, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rdx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x40(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x16cb7
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x1208, %esi           # imm = 0x1208
callq 0x21f0
jmp 0x16d72
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x11f8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, 0x40(%rcx)
movq -0x30(%rbp), %rsi
movq 0x8(%rax), %rcx
movl -0xc(%rbp), %edx
movq %rsi, (%rcx,%rdx,8)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x23e0
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/./command.h
// Function: ident::getval(tagval&) const
inline void ident::getval(tagval &v) const
{
    switch(valtype)
    {
        case VAL_STR: case VAL_MACRO: v.setstr(newstring(val.s)); break;
        case VAL_INT: v.setint(val.i); break;
        case VAL_FLOAT: v.setfloat(val.f); break;
        default: v.setnull(); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x10(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x173c5
movq -0x18(%rbp), %rax
leaq 0x6a8d(%rip), %rcx      # 0x1de00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rdi
callq 0x15990
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x15b80
jmp 0x173ce
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x160b0
jmp 0x173ce
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x20(%rax), %xmm0
callq 0x160d0
jmp 0x173ce
movq -0x10(%rbp), %rdi
callq 0x16780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: sortfun::operator()(sortitem const&, sortitem const&)
bool operator()(const sortitem &xval, const sortitem &yval)
    {
        if(x->valtype != VAL_MACRO) x->valtype = VAL_MACRO;
        cleancode(*x);
        x->val.code = (const uint *)xval.str;
        if(y->valtype != VAL_MACRO) y->valtype = VAL_MACRO;
        cleancode(*y);
        y->val.code = (const uint *)yval.str;
        return executebool(body);
    }

// 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 %rax, -0x20(%rbp)
movq (%rax), %rax
cmpl $0x6, 0x10(%rax)
je 0x179c3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl $0x6, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x47b0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq (%rax), %rcx
movq %rdx, 0x20(%rcx)
movq 0x8(%rax), %rax
cmpl $0x6, 0x10(%rax)
je 0x179fa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x6, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47b0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x20(%rcx)
movq 0x10(%rax), %rdi
callq 0xb030
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)