LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: cleancode(ident&)
static inline void cleancode(ident &id)
{
    if(id.code)
    {
        id.code[0] -= 0x100;
        if(int(id.code[0]) < 0x100) delete[] id.code;
        id.code = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4812
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %ecx
subl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jge 0x4806
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4804
movq -0x10(%rbp), %rdi
callq 0x1b110
jmp 0x4806
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: initidents()
static bool initidents()
{
    initedidents = true;
    for(int i = 0; i < MAXARGS; i++)
    {
        defformatstring(argname)("arg%d", i+1);
        newident(argname, IDF_ARG);
    }
    dummyident = newident("//dummy", IDF_UNKNOWN);
    if(identinits) 
    {
        loopv(*identinits) addident((*identinits)[i]);
        DELETEP(identinits);
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movb $0x1, 0x233ca(%rip)     # 0x27c6c
movl $0x0, -0x4(%rbp)
cmpl $0x19, -0x4(%rbp)
jge 0x48f9
leaq -0x110(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x167a0
movl -0x4(%rbp), %edx
addl $0x1, %edx
leaq -0x118(%rbp), %rdi
leaq 0x199b0(%rip), %rsi     # 0x1e286
movb $0x0, %al
callq 0x167c0
leaq -0x110(%rbp), %rdi
movl $0x40, %esi
callq 0x4e50
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x48a9
leaq 0x1998c(%rip), %rdi     # 0x1e28c
movl $0x20, %esi
callq 0x4e50
movq %rax, 0x22d9f(%rip)     # 0x276b0
cmpq $0x0, 0x23357(%rip)     # 0x27c70
je 0x49c0
movl $0x0, -0x11c(%rbp)
movl -0x11c(%rbp), %eax
movl %eax, -0x120(%rbp)
movq 0x23334(%rip), %rdi     # 0x27c70
callq 0x16860
movl %eax, %ecx
movl -0x120(%rbp), %eax
cmpl %ecx, %eax
jge 0x4978
movq 0x2331c(%rip), %rdi     # 0x27c70
movl -0x11c(%rbp), %esi
callq 0x16880
movq %rax, %rdi
callq 0x4bb0
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x4929
cmpq $0x0, 0x232f0(%rip)     # 0x27c70
je 0x49be
movq 0x232e7(%rip), %rax     # 0x27c70
movq %rax, -0x128(%rbp)
cmpq $0x0, %rax
je 0x49b3
movq -0x128(%rbp), %rdi
callq 0x168c0
movq -0x128(%rbp), %rdi
movl $0x10, %esi
callq 0x21f0
movq $0x0, 0x232b2(%rip) # 0x27c70
jmp 0x49c0
movb $0x1, %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: addcommand(char const*, void (*)(), char const*)
bool addcommand(const char *name, identfun fun, const char *args)
{
    uint argmask = 0;
    int numargs = 0;
    bool limit = true;
    for(const char *fmt = args; *fmt; fmt++) switch(*fmt)
    {
        case 'i': case 'b': case 'f': case 't': case 'N': case 'D': if(numargs < MAXARGS) numargs++; break;
        case 's': case 'e': case 'r': case '$': if(numargs < MAXARGS) { argmask |= 1<<numargs; numargs++; } break;
        case '1': case '2': case '3': case '4': if(numargs < MAXARGS) fmt -= *fmt-'0'+1; break;
        case 'C': case 'V': limit = false; break;
        default: fatal("builtin %s declared with illegal type: %s", name, args); break;
    }
    if(limit && numargs > MAXCOMARGS) fatal("builtin %s declared with too many args: %d", name, numargs);
    addident(ident(ID_COMMAND, name, args, argmask, (void *)fun));
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4ac0
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, -0x78(%rbp)
subl $0x50, %eax
ja 0x4a97
movq -0x78(%rbp), %rax
leaq 0x18636(%rip), %rcx     # 0x1d064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x19, -0x20(%rbp)
jge 0x4a46
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4aad
cmpl $0x19, -0x20(%rbp)
jge 0x4a67
movl -0x20(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4aad
cmpl $0x19, -0x20(%rbp)
jge 0x4a8f
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
subl $0x30, %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x4aad
movb $0x0, -0x21(%rbp)
jmp 0x4aad
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x194b9(%rip), %rdi     # 0x1df5f
movb $0x0, %al
callq 0x40a0
jmp 0x4aaf
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4a01
testb $0x1, -0x21(%rbp)
je 0x4ae1
cmpl $0xc, -0x20(%rbp)
jle 0x4ae1
movq -0x8(%rbp), %rsi
movl -0x20(%rbp), %edx
leaq 0x194af(%rip), %rdi     # 0x1df89
movb $0x0, %al
callq 0x40a0
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x10(%rbp), %r9
leaq -0x70(%rbp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x15d10
leaq -0x70(%rbp), %rdi
callq 0x4bb0
xorl %eax, %eax
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: addident(ident const&)
static inline ident *addident(const ident &id)
{
    if(!initedidents)
    {
        if(!identinits) identinits = new vector<ident>;
        identinits->add(id);
        return NULL;
    }
    ident &def = idents.access(id.name, id);
    def.index = identmap.length();
    return identmap.add(&def);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
testb $0x1, 0x230a9(%rip)     # 0x27c6c
jne 0x4c2d
cmpq $0x0, 0x230a3(%rip)     # 0x27c70
jne 0x4c13
movl $0x10, %edi
callq 0x1b080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x16980
jmp 0x4bea
movq -0x38(%rbp), %rax
movq %rax, 0x2307b(%rip)     # 0x27c70
jmp 0x4c13
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x4c87
movq 0x23056(%rip), %rdi     # 0x27c70
movq -0x10(%rbp), %rsi
callq 0x169b0
movq $0x0, -0x8(%rbp)
jmp 0x4c7d
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
leaq 0x22a40(%rip), %rdi     # 0x27680
callq 0x16a30
movq %rax, -0x28(%rbp)
leaq 0x22a50(%rip), %rdi     # 0x276a0
callq 0x16af0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x22a33(%rip), %rdi     # 0x276a0
leaq -0x30(%rbp), %rsi
callq 0x16b10
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x23e0
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: pusharg(ident&, tagval const&, identstack&)
static inline void pusharg(ident &id, const tagval &v, identstack &stack)
{
    stack.val = id.val;
    stack.valtype = id.valtype;
    stack.next = id.stack;
    id.stack = &stack;
    id.setval(v);
    cleancode(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16100
movq -0x8(%rbp), %rdi
callq 0x47b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: poparg(ident&)
static inline void poparg(ident &id)
{
    if(!id.stack) return;
    identstack *stack = id.stack;
    if(id.valtype == VAL_STR) delete[] id.val.s;
    id.setval(*stack);
    cleancode(id);
    id.stack = stack->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x4d99
jmp 0x4df2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x4dcc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4dca
movq -0x18(%rbp), %rdi
callq 0x1b110
jmp 0x4dcc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16ed0
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: newident(char const*, int)
ident *newident(const char *name, int flags)
{
    ident *id = idents.access(name);
    if(!id)
    {
        if(checknumber(name)) 
        {
            debugcode("number %s is not a valid identifier name", name);
            return dummyident;
        }
        id = addident(ident(ID_ALIAS, newstring(name), flags));
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x2281a(%rip), %rdi     # 0x27680
leaq -0x10(%rbp), %rsi
callq 0x15a10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4ed2
movq -0x10(%rbp), %rdi
callq 0x4ef0
testb $0x1, %al
jne 0x4e89
jmp 0x4ea8
movq -0x10(%rbp), %rsi
leaq 0x18fac(%rip), %rdi     # 0x1de40
movb $0x0, %al
callq 0x4fc0
movq 0x2280e(%rip), %rax     # 0x276b0
movq %rax, -0x8(%rbp)
jmp 0x4eda
movq -0x10(%rbp), %rdi
callq 0x15990
movq %rax, %rdx
movl -0x14(%rbp), %ecx
leaq -0x60(%rbp), %rdi
movl $0x4, %esi
callq 0x15aa0
leaq -0x60(%rbp), %rdi
callq 0x4bb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: checknumber(char const*)
static inline bool checknumber(const char *s)
{
    if(isdigit(s[0])) return true;
    else switch(s[0])
    {
        case '+': case '-': return isdigit(s[1]) || (s[1] == '.' && isdigit(s[2]));
        case '.': return isdigit(s[1]) != 0;
        default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x21b0
cmpl $0x0, %eax
je 0x4f16
movb $0x1, -0x1(%rbp)
jmp 0x4faa
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2b, %eax
je 0x4f3b
jmp 0x4f27
movl -0x14(%rbp), %eax
subl $0x2d, %eax
je 0x4f3b
jmp 0x4f31
movl -0x14(%rbp), %eax
subl $0x2e, %eax
je 0x4f8c
jmp 0x4fa6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x21b0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x4f82
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x16(%rbp)
jne 0x4f7c
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x21b0
cmpl $0x0, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4faa
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x21b0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4faa
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: debugcode(char const*, ...)
static void debugcode(const char *fmt, ...)
{
    if(nodebug) return;

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

    debugalias();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4ff5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x226c9(%rip)     # 0x276ec
je 0x5027
jmp 0x5066
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movl $0x4, %edi
callq 0x40c0
leaq -0x20(%rbp), %rax
callq 0xf8d0
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: writeident(char const*, int)
ident *writeident(const char *name, int flags)
{
    ident *id = newident(name, flags);
    if(id->index < MAXARGS && !(aliasstack->usedargs&(1<<id->index)))
    {
        pusharg(*id, nullval, aliasstack->argstack[id->index]);
        aliasstack->usedargs |= 1<<id->index;
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4e50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x19, 0x3c(%rax)
jge 0x5101
movq 0x22198(%rip), %rax     # 0x27238
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x3c(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x5101
movq -0x18(%rbp), %rdi
movq 0x22173(%rip), %rax     # 0x27238
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movslq 0x3c(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
leaq 0x225e1(%rip), %rsi     # 0x276c0
callq 0x4d10
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x2213d(%rip), %rax     # 0x27238
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: readident(char const*)
ident *readident(const char *name)
{
    ident *id = idents.access(name);
    if(id && id->index < MAXARGS && !(aliasstack->usedargs&(1<<id->index)))
       return NULL;
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2255d(%rip), %rdi     # 0x27680
leaq -0x10(%rbp), %rsi
callq 0x15a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x516c
movq -0x18(%rbp), %rax
cmpl $0x19, 0x3c(%rax)
jge 0x516c
movq 0x220f0(%rip), %rax     # 0x27238
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x3c(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x516c
movq $0x0, -0x8(%rbp)
jmp 0x5174
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: resetvar(char*)
void resetvar(char *name)
{
    ident *id = idents.access(name);
    if(!id) return;
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else clearoverride(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x224ed(%rip), %rdi     # 0x27680
leaq -0x8(%rbp), %rsi
callq 0x15af0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x51a9
jmp 0x51d9
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x51d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x18ca2(%rip), %rdi     # 0x1de69
movb $0x0, %al
callq 0x4fc0
jmp 0x51d9
movq -0x10(%rbp), %rdi
callq 0x4670
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setalias(char const*, tagval&)
static void setalias(const char *name, tagval &v)
{
    ident *id = idents.access(name);
    if(id) 
    {
        if(id->type == ID_ALIAS) 
        {
            if(id->index < MAXARGS) setarg(*id, v); else setalias(*id, v);
        }
        else
        {
            debugcode("cannot redefine builtin %s with an alias", id->name);
            freearg(v);
        }
    }
    else if(checknumber(name)) 
    {
        debugcode("cannot alias number %s", name);
        freearg(v);
    }
    else
    {
        addident(ident(ID_ALIAS, newstring(name), v, identflags));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x22449(%rip), %rdi     # 0x27680
leaq -0x8(%rbp), %rsi
callq 0x15a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x529d
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x527c
movq -0x18(%rbp), %rax
cmpl $0x19, 0x3c(%rax)
jge 0x526d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf9f0
jmp 0x527a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfab0
jmp 0x529b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1901d(%rip), %rdi     # 0x1e2a8
movb $0x0, %al
callq 0x4fc0
movq -0x10(%rbp), %rdi
callq 0x4500
jmp 0x52f9
movq -0x8(%rbp), %rdi
callq 0x4ef0
testb $0x1, %al
jne 0x52ac
jmp 0x52c9
movq -0x8(%rbp), %rsi
leaq 0x1901a(%rip), %rdi     # 0x1e2d1
movb $0x0, %al
callq 0x4fc0
movq -0x10(%rbp), %rdi
callq 0x4500
jmp 0x52f7
movq -0x8(%rbp), %rdi
callq 0x15990
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl 0x223d8(%rip), %r8d     # 0x276b8
leaq -0x58(%rbp), %rdi
movl $0x4, %esi
callq 0x16f00
leaq -0x58(%rbp), %rdi
callq 0x4bb0
jmp 0x52f9
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setvar(char const*, int, bool, bool)
void setvar(const char *name, int i, bool dofunc, bool doclamp)
{
    GETVAR(id, name, );
    OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
    if(doclamp) *id->storage.i = clamp(i, id->minval, id->maxval);
    else *id->storage.i = i;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %cl
movb %cl, -0xd(%rbp)
andb $0x1, %al
movb %al, -0xe(%rbp)
leaq 0x2222b(%rip), %rdi     # 0x27680
leaq -0x8(%rbp), %rsi
callq 0x15a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5472
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5477
jmp 0x5555
movl 0x2223b(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x5494
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x54f1
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54be
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x189d9(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x5555
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x54ed
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x54ef
jmp 0x54ef
jmp 0x550f
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x550d
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
jmp 0x550f
testb $0x1, -0xe(%rbp)
je 0x5539
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x5560
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, (%rax)
jmp 0x5546
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, (%rax)
testb $0x1, -0xd(%rbp)
je 0x5555
movq -0x18(%rbp), %rdi
callq 0x159e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvar(char const*, float, bool, bool)
void setfvar(const char *name, float f, bool dofunc, bool doclamp)
{
    _GETVAR(id, ID_FVAR, name, );
    OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
    if(doclamp) *id->storage.f = clamp(f, id->minvalf, id->maxvalf);
    else *id->storage.f = f;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
andb $0x1, %cl
movb %cl, -0xd(%rbp)
andb $0x1, %al
movb %al, -0xe(%rbp)
leaq 0x220b8(%rip), %rdi     # 0x27680
leaq -0x8(%rbp), %rsi
callq 0x15a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x55e5
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x55ea
jmp 0x56d6
movl 0x220c8(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x5607
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5668
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5631
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x18866(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x56d6
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x5664
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5666
jmp 0x5666
jmp 0x5686
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x5684
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5686
testb $0x1, -0xe(%rbp)
je 0x56b6
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm2
callq 0x56e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movss %xmm0, (%rax)
jmp 0x56c7
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movss %xmm0, (%rax)
testb $0x1, -0xd(%rbp)
je 0x56d6
movq -0x18(%rbp), %rdi
callq 0x159e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvar(char const*, char const*, bool)
void setsvar(const char *name, const char *str, bool dofunc)
{
    _GETVAR(id, ID_SVAR, name, );
    OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
    *id->storage.s = newstring(str);
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x21f32(%rip), %rdi     # 0x27680
leaq -0x8(%rbp), %rsi
callq 0x15a10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x576b
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0x5770
jmp 0x5887
movl 0x21f42(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x578d
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x580a
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x57b7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x186e0(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x5887
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x57e8
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5808
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5806
movq -0x28(%rbp), %rdi
callq 0x1b110
jmp 0x5808
jmp 0x5861
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x5841
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5834
movq -0x30(%rbp), %rdi
callq 0x1b110
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x585f
movq -0x38(%rbp), %rdi
callq 0x1b110
jmp 0x5861
movq -0x10(%rbp), %rdi
callq 0x15990
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
testb $0x1, -0x11(%rbp)
je 0x5887
movq -0x20(%rbp), %rdi
callq 0x159e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: clampvar(ident*, int, int, int)
int clampvar(ident *id, int val, int minval, int maxval)
{
    if(val < minval) val = minval;
    else if(val > maxval) val = maxval;
    else return val;
    debugcode(id->flags&IDF_HEX ?
            (minval <= 255 ? "valid range for %s is %d..0x%X" : "valid range for %s is 0x%X..0x%X") :
            "valid range for %s is %d..%d",
        id->name, minval, maxval);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5d05
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5d1f
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x5d15
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5d1d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d7b
jmp 0x5d1f
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5d4f
movl -0x18(%rbp), %edx
leaq 0x181cc(%rip), %rax     # 0x1df04
leaq 0x181a6(%rip), %rcx     # 0x1dee5
cmpl $0xff, %edx
cmovleq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x5d5c
leaq 0x181cf(%rip), %rax     # 0x1df25
movq %rax, -0x28(%rbp)
jmp 0x5d5c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movb $0x0, %al
callq 0x4fc0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setvarchecked(ident*, int)
void setvarchecked(ident *id, int val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
        if(val < id->minval || val > id->maxval) val = clampvar(id, val, id->minval, id->maxval);
        *id->storage.i = val;
        id->changed();                                             // call trigger function if available
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5dc9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x180ac(%rip), %rdi     # 0x1de69
movb $0x0, %al
callq 0x4fc0
jmp 0x5eac
movl 0x218e9(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x5de6
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5e43
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5e10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x18087(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x5eac
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x5e3f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5e41
jmp 0x5e41
jmp 0x5e61
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x5e5f
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5e61
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x5e79
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jle 0x5e96
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
callq 0x5ce0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: clampfvar(ident*, float, float, float)
float clampfvar(ident *id, float val, float minval, float maxval)
{
    if(val < minval) val = minval;
    else if(val > maxval) val = maxval;
    else return val;
    debugcode("valid range for %s is %s..%s", id->name, floatstr(minval), floatstr(maxval));
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss -0x14(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5ef6
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x5f1b
movss -0x14(%rbp), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x5f0d
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x5f19
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x5f62
jmp 0x5f1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movss -0x18(%rbp), %xmm0
callq 0x5f70
movq %rax, -0x28(%rbp)
movss -0x1c(%rbp), %xmm0
callq 0x5f70
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x17ff1(%rip), %rdi     # 0x1df42
movb $0x0, %al
callq 0x4fc0
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvarchecked(ident*, float)
void setfvarchecked(ident *id, float val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
        if(val < id->minvalf || val > id->maxvalf) val = clampfvar(id, val, id->minvalf, id->maxvalf);
        *id->storage.f = val;
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x601b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x17e5a(%rip), %rdi     # 0x1de69
movb $0x0, %al
callq 0x4fc0
jmp 0x6118
movl 0x21697(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x6038
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6099
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6062
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x17e35(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x6118
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x6095
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x6097
jmp 0x6097
jmp 0x60b7
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x60b5
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
jmp 0x60b7
movss -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x60d9
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x18(%rax), %xmm0
jbe 0x60fe
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm2
callq 0x5ec0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvarchecked(ident*, char const*)
void setsvarchecked(ident *id, const char *val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
        *id->storage.s = newstring(val);
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x615a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x17d1b(%rip), %rdi     # 0x1de69
movb $0x0, %al
callq 0x4fc0
jmp 0x626b
movl 0x21558(%rip), %eax     # 0x276b8
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x6177
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x61f4
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x61a1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x17cf6(%rip), %rdi     # 0x1de8b
movb $0x0, %al
callq 0x4fc0
jmp 0x626b
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x61d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
jmp 0x61f2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x61f0
movq -0x18(%rbp), %rdi
callq 0x1b110
jmp 0x61f2
jmp 0x624b
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x622b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x621e
movq -0x20(%rbp), %rdi
callq 0x1b110
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6249
movq -0x28(%rbp), %rdi
callq 0x1b110
jmp 0x624b
movq -0x10(%rbp), %rdi
callq 0x15990
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: parsestring(char const*)
const char *parsestring(const char *p)
{
    for(; *p; p++) switch(*p)
    {
        case '\r':
        case '\n':
        case '\"':
            return p;
        case '^':
            if(*++p) break;
            return p;
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x62fb
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa, %eax
je 0x62c0
jmp 0x62a2
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x62c0
jmp 0x62ac
movl -0x14(%rbp), %eax
subl $0x22, %eax
je 0x62c0
jmp 0x62b6
movl -0x14(%rbp), %eax
subl $0x5e, %eax
je 0x62ca
jmp 0x62eb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6303
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, 0x1(%rax)
je 0x62e1
jmp 0x62eb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6303
jmp 0x62ed
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6288
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: unescapestring(char*, char const*, char const*)
int unescapestring(char *dst, const char *src, const char *end)
{
    char *start = dst;
    while(src < end)
    {
        int c = *src++;
        if(c == '^')
        {
            if(src >= end) break;
            int e = *src++;
            switch(e)
            {
                case 'n': *dst++ = '\n'; break;
                case 't': *dst++ = '\t'; break;
                case 'f': *dst++ = '\f'; break;
                default: *dst++ = e; break;
            }
        }
        else *dst++ = c;
    }
    return dst - start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6408
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x5e, -0x24(%rbp)
jne 0x63ed
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x6364
jmp 0x6408
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x66, %eax
je 0x63c1
jmp 0x6385
movl -0x2c(%rbp), %eax
subl $0x6e, %eax
je 0x6399
jmp 0x638f
movl -0x2c(%rbp), %eax
subl $0x74, %eax
je 0x63ad
jmp 0x63d5
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0xa, (%rax)
jmp 0x63eb
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x9, (%rax)
jmp 0x63eb
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0xc, (%rax)
jmp 0x63eb
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x6403
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x6328
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: compilecode(char const*)
uint *compilecode(const char *p)
{
    vector<uint> buf;
    buf.reserve(64);
    compilemain(buf, p);
    uint *code = new uint[buf.length()];
    memcpy(code, buf.getbuf(), buf.length()*sizeof(uint));
    code[0] += 0x100;
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15d60
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x40, %edx
callq 0x15d90
jmp 0x6450
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movl $0x4, %edx
callq 0x6530
jmp 0x6464
leaq -0x18(%rbp), %rdi
callq 0x15e00
movl %eax, -0x54(%rbp)
jmp 0x6472
movl -0x54(%rbp), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x1b0b0
movq %rax, -0x60(%rbp)
jmp 0x6498
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e20
movq %rax, -0x68(%rbp)
jmp 0x64b7
leaq -0x18(%rbp), %rdi
callq 0x15e00
movl %eax, -0x74(%rbp)
jmp 0x64c5
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x2170
movq -0x48(%rbp), %rax
movl (%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e40
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e40
movq -0x38(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: keepcode(unsigned int*)
void keepcode(uint *code)
{
    if(!code) return;
    switch(*code&CODE_OP_MASK)
    {
        case CODE_START:
            *code += 0x100;
            return;
    }
    switch(code[-1]&CODE_OP_MASK)
    {
        case CODE_START:
            code[-1] += 0x100;
            break;
        case CODE_OFFSET:
            code -= int(code[-1]>>8);
            *code += 0x100;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x65c1
jmp 0x6639
movq -0x8(%rbp), %rax
movb (%rax), %al
testb $0x3f, %al
jne 0x65dd
jmp 0x65cd
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
jmp 0x6639
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
andl $0x3f, %eax
movl %eax, -0xc(%rbp)
je 0x65f8
jmp 0x65ee
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x660a
jmp 0x6639
movq -0x8(%rbp), %rax
movl -0x4(%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x4(%rax)
jmp 0x6639
movq -0x8(%rbp), %rax
movl -0x4(%rax), %ecx
shrl $0x8, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: freecode(unsigned int*)
void freecode(uint *code)
{
    if(!code) return;
    switch(*code&CODE_OP_MASK)
    {   
        case CODE_START:
            *code -= 0x100;
            if(int(*code) < 0x100) delete[] code;
            return;
    }
    switch(code[-1]&CODE_OP_MASK)
    {
        case CODE_START:
            code[-1] -= 0x100;
            if(int(code[-1]) < 0x100) delete[] &code[-1];
            break;
        case CODE_OFFSET:
            code -= int(code[-1]>>8);
            *code -= 0x100;
            if(int(*code) < 0x100) delete[] code;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6658
jmp 0x674c
movq -0x8(%rbp), %rax
movb (%rax), %al
testb $0x3f, %al
jne 0x669c
jmp 0x6664
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jge 0x6697
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6695
movq -0x10(%rbp), %rdi
callq 0x1b110
jmp 0x6697
jmp 0x674c
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
je 0x66ba
jmp 0x66ad
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x66f6
jmp 0x674c
movq -0x8(%rbp), %rax
movl -0x4(%rax), %ecx
subl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x100, -0x4(%rax)      # imm = 0x100
jge 0x66f4
movq -0x8(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x66f2
movq -0x20(%rbp), %rdi
callq 0x1b110
jmp 0x66f4
jmp 0x674c
movq -0x8(%rbp), %rax
movl -0x4(%rax), %ecx
shrl $0x8, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jge 0x674a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6748
movq -0x28(%rbp), %rdi
callq 0x1b110
jmp 0x674a
jmp 0x674c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: printvar(ident*, int)
void printvar(ident *id, int i)
{
    if(i < 0) conoutf("%s = %d", id->name, i);
    else if(id->flags&IDF_HEX && id->maxval==0xFFFFFF)
        conoutf("%s = 0x%.6X (%d, %d, %d)", id->name, i, (i>>16)&0xFF, (i>>8)&0xFF, i&0xFF);
    else
        conoutf(id->flags&IDF_HEX ? "%s = 0x%X" : "%s = %d", id->name, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6793
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %edx
leaq 0x1782d(%rip), %rdi     # 0x1dfb4
movb $0x0, %al
callq 0x40f0
jmp 0x6823
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x67f0
movq -0x8(%rbp), %rax
cmpl $0xffffff, 0x18(%rax)   # imm = 0xFFFFFF
jne 0x67f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %edx
movl -0xc(%rbp), %ecx
sarl $0x10, %ecx
andl $0xff, %ecx
movl -0xc(%rbp), %r8d
sarl $0x8, %r8d
andl $0xff, %r8d
movl -0xc(%rbp), %r9d
andl $0xff, %r9d
leaq 0x177d5(%rip), %rdi     # 0x1dfbc
movb $0x0, %al
callq 0x40f0
jmp 0x6821
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $0x4, %ecx
leaq 0x177b3(%rip), %rdi     # 0x1dfb4
leaq 0x177cd(%rip), %rax     # 0x1dfd5
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %edx
movb $0x0, %al
callq 0x40f0
jmp 0x6823
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: printvar(ident*)
void printvar(ident *id)
{
    switch(id->type)
    {
        case ID_VAR: printvar(id, *id->storage.i); break;
        case ID_FVAR: printfvar(id, *id->storage.f); break;
        case ID_SVAR: printsvar(id, *id->storage.s); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x690f
jmp 0x68fb
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x6924
jmp 0x6905
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x693b
jmp 0x694f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %esi
callq 0x6760
jmp 0x694f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movss (%rax), %xmm0
callq 0x6830
jmp 0x694f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rsi
callq 0x6880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: executeret(char const*, tagval&)
void executeret(const char *p, tagval &result)
{
    vector<uint> code;
    code.reserve(64);
    compilemain(code, p, VAL_ANY);
    runcode(code.getbuf()+1, result);
    if(int(code[0]) >= 0x100) code.disown();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15d60
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x40, %edx
callq 0x15d90
jmp 0xad21
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x4, %edx
callq 0x6530
jmp 0xad35
leaq -0x20(%rbp), %rdi
callq 0x15e20
movq %rax, -0x58(%rbp)
jmp 0xad44
movq -0x58(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
callq 0x6960
jmp 0xad57
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x15ea0
movq %rax, -0x60(%rbp)
jmp 0xad68
movq -0x60(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0xad98
leaq -0x20(%rbp), %rdi
callq 0x15ee0
jmp 0xad7f
jmp 0xad98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15e40
jmp 0xada7
leaq -0x20(%rbp), %rdi
callq 0x15e40
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23e0
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: executestr(unsigned int const*)
char *executestr(const uint *code)
{
    tagval result;
    runcode(code, result);
    if(result.type == VAL_NULL) return NULL;
    forcestr(result);
    return result.s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6960
cmpl $0x0, -0x18(%rbp)
jne 0xadd9
movq $0x0, -0x8(%rbp)
jmp 0xadea
leaq -0x20(%rbp), %rdi
callq 0xae00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: forcestr(tagval&)
static inline const char *forcestr(tagval &v)
{
    const char *s = "";
    switch(v.type)
    {
        case VAL_FLOAT: s = floatstr(v.f); break;
        case VAL_INT: s = intstr(v.i); break;
        case VAL_STR: case VAL_MACRO: return v.s;
    }
    freearg(v);
    v.setstr(newstring(s));
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1356c(%rip), %rax     # 0x1e37f
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0xae70
movq -0x20(%rbp), %rax
leaq 0x127ca(%rip), %rcx     # 0x1d600
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
callq 0x5f70
movq %rax, -0x18(%rbp)
jmp 0xae70
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xb7b0
movq %rax, -0x18(%rbp)
jmp 0xae70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xae9e
movq -0x10(%rbp), %rdi
callq 0x4500
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15990
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x15b80
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: executestr(char const*)
char *executestr(const char *p)
{
    tagval result;
    executeret(p, result);
    if(result.type == VAL_NULL) return NULL;
    forcestr(result);
    return result.s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xacf0
cmpl $0x0, -0x18(%rbp)
jne 0xaed9
movq $0x0, -0x8(%rbp)
jmp 0xaeea
leaq -0x20(%rbp), %rdi
callq 0xae00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: execute(unsigned int const*)
int execute(const uint *code)
{
    tagval result;
    runcode(code, result);
    int i = result.getint();
    freearg(result);
    return i;
}

// 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 0x15f10
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4500
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)