LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edx, %ebx
cmpl %edx, %esi
jl 0x450d
movl %esi, %eax
movl %ecx, %ebx
cmpl %ecx, %esi
jle 0x4544
cmpl $0x100, %edx            # imm = 0x100
leaq 0xd35b(%rip), %rax      # 0x11875
leaq 0xd373(%rip), %rsi      # 0x11894
cmovlq %rax, %rsi
testb $0x4, 0x38(%rdi)
leaq 0xd385(%rip), %rax      # 0x118b5
cmovneq %rsi, %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x3cc9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4583
movl 0x15147(%rip), %ecx     # 0x196a8
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4590
testb $0x1, %al
jne 0x45d5
testb $0x10, %al
jne 0x459a
movq 0x20(%rbx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rbx)
orl $0x10, %eax
jmp 0x4597
movq 0x8(%rbx), %rsi
leaq 0xd26b(%rip), %rdi      # 0x117f9
jmp 0x45e0
testb $0x10, %al
je 0x459a
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movl 0x10(%rbx), %edx
movl 0x18(%rbx), %ecx
cmpl %esi, %edx
setg %al
cmpl %esi, %ecx
setl %dil
orb %al, %dil
cmpb $0x1, %dil
jne 0x45be
movq %rbx, %rdi
callq 0x44f9
movl %eax, %esi
movq 0x20(%rbx), %rax
movl %esi, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x45ed
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0xd23b(%rip), %rdi      # 0x1181b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3cc9
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x46d3
movl 0x14ffb(%rip), %ecx     # 0x196a8
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x46e0
testb $0x1, %al
jne 0x471f
testb $0x10, %al
jne 0x46ea
movq 0x20(%rbx), %rcx
movss (%rcx), %xmm1
movss %xmm1, 0x28(%rbx)
orl $0x10, %eax
jmp 0x46e7
movq 0x8(%rbx), %rsi
leaq 0xd11b(%rip), %rdi      # 0x117f9
jmp 0x472a
testb $0x10, %al
je 0x46ea
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movss 0x10(%rbx), %xmm1
movss 0x18(%rbx), %xmm2
ucomiss %xmm0, %xmm1
ja 0x46fe
ucomiss %xmm2, %xmm0
jbe 0x4706
movq %rbx, %rdi
callq 0x45f0
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x4737
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0xd0f1(%rip), %rdi      # 0x1181b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3cc9
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x477b
movq %rsi, %r14
movl 0x14f54(%rip), %ecx     # 0x196a8
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4788
testb $0x1, %al
jne 0x47d2
movq 0x20(%rbx), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x47aa
movq %rdi, 0x28(%rbx)
orl $0x10, %eax
movl %eax, 0x38(%rbx)
jmp 0x47b4
movq 0x8(%rbx), %rsi
leaq 0xd073(%rip), %rdi      # 0x117f9
jmp 0x47dd
testb $0x10, %al
je 0x47a3
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x479d
callq 0xf9a8
movl 0x38(%rbx), %eax
andl $-0x11, %eax
movl %eax, 0x38(%rbx)
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x47b4
callq 0xf9a8
movq %r14, %rdi
callq 0xd0ec
movq 0x20(%rbx), %rcx
movq %rax, (%rcx)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x47e8
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0xd03e(%rip), %rdi      # 0x1181b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3cc9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
cmpq %rdx, %rsi
jae 0x486f
leaq 0x1(%rsi), %r8
movb (%rsi), %cl
cmpb $0x5e, %cl
jne 0x485c
cmpq %rdx, %r8
jae 0x486f
movzbl 0x1(%rsi), %ecx
addq $0x2, %rsi
cmpl $0x66, %ecx
je 0x486b
cmpl $0x6e, %ecx
je 0x4867
cmpl $0x74, %ecx
jne 0x485f
movb $0x9, %cl
jmp 0x485f
movq %r8, %rsi
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x482c
movb $0xa, %cl
jmp 0x485f
movb $0xc, %cl
jmp 0x485f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq -0x48(%rbp), %rdi
pushq $0x40
popq %rdx
callq 0xd1d6
leaq -0x30(%rbp), %rdi
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x490b
movslq -0x24(%rbp), %rax
leaq (,%rax,4), %rbx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rbx, %rdi
callq 0xf989
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq (%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2150
addl $0x100, (%r14)          # imm = 0x100
movq %r15, %rdi
callq 0xd228
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48f7
jmp 0x48f7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xd228
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x49a9
movl (%rdi), %eax
testb $0x3f, %al
je 0x499d
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
je 0x4999
cmpl $0x1, %ecx
jne 0x49a9
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl (%rdi), %eax
jmp 0x499d
addq $-0x4, %rdi
pushq %rbp
movq %rsp, %rbp
addl $0x100, %eax            # imm = 0x100
movl %eax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
testq %rdi, %rdi
je 0x49dc
movl (%rdi), %eax
testb $0x3f, %al
je 0x49de
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1, %ecx
je 0x49f2
testl %ecx, %ecx
jne 0x49dc
addq $-0x4, %rdi
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jl 0x49ec
popq %rbp
retq
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jge 0x49dc
popq %rbp
jmp 0xf9a8
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
addl (%rdi), %eax
movl %eax, (%rdi)
cmpl $0xff, %eax
jg 0x49dc
jmp 0x49ec
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %edx
testl %esi, %esi
js 0x4a26
testb $0x4, 0x38(%rdi)
jne 0x4a33
leaq 0xcf20(%rip), %rax      # 0x11944
jmp 0x4a71
movq 0x8(%rdi), %rsi
leaq 0xcf13(%rip), %rdi      # 0x11944
jmp 0x4a78
cmpl $0xffffff, 0x18(%rdi)   # imm = 0xFFFFFF
jne 0x4a6a
movq 0x8(%rdi), %rsi
movl %edx, %ecx
shrl $0x10, %ecx
movl $0xff, %r9d
andl %r9d, %ecx
movl %edx, %r8d
shrl $0x8, %r8d
andl %r9d, %r8d
andl %edx, %r9d
leaq 0xceea(%rip), %rdi      # 0x1194c
xorl %eax, %eax
popq %rbp
jmp 0x350f
leaq 0xcef4(%rip), %rax      # 0x11965
movq 0x8(%rdi), %rsi
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x350f
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x4b16
cmpl $0x1, %eax
je 0x4b08
testl %eax, %eax
jne 0x4b23
movq 0x20(%rdi), %rax
movl (%rax), %esi
popq %rbp
jmp 0x4a0d
movq 0x20(%rdi), %rax
movss (%rax), %xmm0
popq %rbp
jmp 0x4a80
movq 0x20(%rdi), %rax
movq (%rax), %rsi
popq %rbp
jmp 0x4aa9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq -0x38(%rbp), %rdi
pushq $0x40
popq %rdx
callq 0xd1d6
leaq -0x20(%rbp), %rdi
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x490b
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x4b25
movq -0x20(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x6e12
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd228
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x6e26
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xd228
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movq %rbx, %rsi
callq 0x4b25
cmpl $0x0, 0x8(%rbx)
je 0x6e62
movq %rbx, %rdi
callq 0x6e6b
movq (%rbx), %rax
jmp 0x6e64
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leaq 0xae90(%rip), %r14      # 0x11d0f
decl %eax
cmpl $0x5, %eax
ja 0x6eb0
leaq 0xa65f(%rip), %rcx      # 0x114ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %r14
jmp 0x6eca
movss (%rbx), %xmm0
callq 0x4653
jmp 0x6ead
movl (%rbx), %edi
callq 0x748f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3745
movq %r14, %rdi
callq 0xd0ec
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movq %rbx, %rsi
callq 0x6db9
cmpl $0x0, 0x8(%rbx)
je 0x6efa
movq %rbx, %rdi
callq 0x6e6b
movq (%rbx), %rax
jmp 0x6efc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x20(%rbp), %rbx
movq %rbx, %rsi
callq 0x4b25
movq %rbx, %rdi
callq 0xd240
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3745
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: execute(char const*)
int execute(const char *p)
{
    vector<uint> code;
    code.reserve(64);
    compilemain(code, p, VAL_INT);
    tagval result;
    runcode(code.getbuf()+1, result);
    if(int(code[0]) >= 0x100) code.disown();
    int i = result.getint();
    freearg(result);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq -0x38(%rbp), %rdi
pushq $0x40
popq %rdx
callq 0xd1d6
leaq -0x20(%rbp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x490b
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4b25
movq -0x20(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x6f90
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0xd240
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3745
leaq -0x20(%rbp), %rdi
callq 0xd228
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x6fc0
jmp 0x6fc0
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xd228
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: executebool(unsigned int const*)
bool executebool(const uint *code)
{
    tagval result;
    runcode(code, result);
    bool b = getbool(result);
    freearg(result);
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x20(%rbp), %rbx
movq %rbx, %rsi
callq 0x4b25
movq %rbx, %rdi
callq 0x700a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3745
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: getbool(tagval const&)
static inline bool getbool(const tagval &v)
{
    switch(v.type)
    {
        case VAL_FLOAT: return v.f!=0;
        case VAL_INT: return v.i!=0;
        case VAL_STR: case VAL_MACRO: return getbool(v.s);
        default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x8(%rdi), %ecx
xorl %eax, %eax
decl %ecx
cmpl $0x5, %ecx
ja 0x70d8
leaq 0xa4dd(%rip), %rdx      # 0x11504
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rbx
movzbl (%rbx), %ecx
leal -0x2b(%rcx), %eax
cmpl $0x5, %eax
ja 0x70a7
leaq 0xa4d7(%rip), %rcx      # 0x1151c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0x1(%rbx), %ecx
cmpl $0x30, %ecx
je 0x707d
movb $0x1, %al
cmpl $0x2e, %ecx
jne 0x70d8
movsbl 0x2(%rbx), %ecx
addl $-0x30, %ecx
jmp 0x70bc
xorps %xmm0, %xmm0
cmpneqss (%rdi), %xmm0
movd %xmm0, %eax
jmp 0x70d5
cmpl $0x0, (%rdi)
setne %al
jmp 0x70d8
leaq -0x10(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2060
movq %rax, %rcx
movb $0x1, %al
testl %ecx, %ecx
jne 0x70d8
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x65, %eax
je 0x70c1
cmpl $0x2e, %eax
je 0x70c1
jmp 0x70ab
testl %ecx, %ecx
jne 0x70af
xorl %eax, %eax
jmp 0x70d8
movb $0x1, %al
jmp 0x70d8
movsbl 0x1(%rbx), %ecx
addl $-0x30, %ecx
movb $0x1, %al
cmpl $0x9, %ecx
ja 0x70d8
movq %rbx, %rdi
callq 0xbcd7
xorps %xmm1, %xmm1
cmpneqss %xmm0, %xmm1
movd %xmm1, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: executebool(char const*)
bool executebool(const char *p)
{
    tagval result;
    executeret(p, result);
    bool b = getbool(result);
    freearg(result);
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x20(%rbp), %rbx
movq %rbx, %rsi
callq 0x6db9
movq %rbx, %rdi
callq 0x700a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3745
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: execfile(char const*, bool)
bool execfile(const char *cfgfile, bool msg)
{
    string s;
    copystring(s, cfgfile);
    char *buf = loadfile(path(s), NULL);
    if(!buf)
    {
        if(msg) conoutf(CON_ERROR, "could not read \"%s\"", cfgfile);
        return false;
    }
    const char *oldsourcefile = sourcefile, *oldsourcestr = sourcestr;
    sourcefile = cfgfile;
    sourcestr = buf;
    execute(buf);
    sourcefile = oldsourcefile;
    sourcestr = oldsourcestr;
    delete[] buf;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x130(%rbp), %r14
movl $0x104, %edx            # imm = 0x104
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd24d
movq %r14, %rdi
callq 0xe156
pushq $0x1
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0xedc9
movq %rax, %r14
testq %rax, %rax
je 0x719d
movq 0x12580(%rip), %r15     # 0x196e8
movq 0x12581(%rip), %r12     # 0x196f0
movq %rbx, 0x12572(%rip)     # 0x196e8
movq %r14, 0x12573(%rip)     # 0x196f0
movq %r14, %rdi
callq 0x6f39
movq %r15, 0x1255c(%rip)     # 0x196e8
movq %r12, 0x1255d(%rip)     # 0x196f0
movq %r14, %rdi
callq 0xf9a8
jmp 0x71b6
testb %r15b, %r15b
je 0x71b6
leaq 0xa7e2(%rip), %rsi      # 0x1198b
pushq $0x4
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x358a
testq %r14, %r14
setne %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: escapestring(char const*)
const char *escapestring(const char *s)
{
    static vector<char> strbuf[3];
    static int stridx = 0;
    stridx = (stridx + 1)%3;
    vector<char> &buf = strbuf[stridx];
    buf.setsize(0);
    buf.add('"');
    for(; *s; s++) switch(*s)
    {
        case '\n': buf.put("^n", 2); break;
        case '\t': buf.put("^t", 2); break;
        case '\f': buf.put("^f", 2); break;
        case '"': buf.put("^\"", 2); break;
        case '^': buf.put("^^", 2); break;
        default: buf.add(*s); break;
    }
    buf.put("\"\0", 2);
    return buf.getbuf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x12525(%rip), %al      # 0x19730
testb %al, %al
je 0x72ec
movl 0x1251f(%rip), %eax     # 0x19738
incl %eax
pushq $0x3
popq %rcx
xorl %edx, %edx
divl %ecx
movl %edx, 0x12510(%rip)     # 0x19738
shll $0x4, %edx
leaq 0x124ce(%rip), %rax     # 0x19700
andl $0x0, 0xc(%rdx,%rax)
leaq (%rax,%rdx), %r14
leaq -0x29(%rbp), %rsi
movb $0x22, (%rsi)
movq %r14, %rdi
callq 0xd296
pushq $0x2
popq %r12
leaq 0xa75b(%rip), %r13      # 0x119b0
leaq 0xa757(%rip), %r15      # 0x119b3
movzbl (%rbx), %eax
cmpl $0x9, %eax
je 0x729d
cmpl $0xa, %eax
je 0x72b1
cmpl $0xc, %eax
je 0x7289
cmpl $0x22, %eax
je 0x72a9
cmpl $0x5e, %eax
je 0x7295
testl %eax, %eax
je 0x72c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd296
jmp 0x72c3
movq %r14, %rdi
leaq 0xa71a(%rip), %rsi      # 0x119ad
jmp 0x72bb
movq %r14, %rdi
movq %r15, %rsi
jmp 0x72bb
movq %r14, %rdi
leaq 0xa703(%rip), %rsi      # 0x119aa
jmp 0x72bb
movq %r14, %rdi
movq %r13, %rsi
jmp 0x72bb
movq %r14, %rdi
leaq 0xa6ec(%rip), %rsi      # 0x119a7
movl %r12d, %edx
callq 0xd2d6
incq %rbx
jmp 0x725c
leaq 0xa445(%rip), %rsi      # 0x11714
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0xd2d6
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1243d(%rip), %rdi     # 0x19730
callq 0x23d0
testl %eax, %eax
je 0x7213
xorps %xmm0, %xmm0
movaps %xmm0, 0x12416(%rip)    # 0x19720
movaps %xmm0, 0x123ff(%rip)    # 0x19710
movaps %xmm0, 0x123e8(%rip)    # 0x19700
leaq -0x4eff(%rip), %rdi     # 0x2420
leaq 0x11eea(%rip), %rdx     # 0x19210
xorl %esi, %esi
callq 0x2180
leaq 0x123fc(%rip), %rdi     # 0x19730
callq 0x2110
jmp 0x7213
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: validateblock(char const*)
bool validateblock(const char *s)
{
    const int maxbrak = 100;
    static char brakstack[maxbrak];
    int brakdepth = 0;
    for(; *s; s++) switch(*s)
    {
        case '[': case '(': if(brakdepth >= maxbrak) return false; brakstack[brakdepth++] = *s; break;
        case ']': if(brakdepth <= 0 || brakstack[--brakdepth] != '[') return false; break;
        case ')': if(brakdepth <= 0 || brakstack[--brakdepth] != '(') return false; break;
        case '"': s = parsestring(s + 1); if(*s != '"') return false; break;
        case '/': if(s[1] == '/') return false; break;
        case '@': case '\f': return false;
    }
    return brakdepth == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rax
xorl %ebx, %ebx
leaq 0x1233f(%rip), %r14     # 0x19740
movzbl (%rax), %edx
cmpl $0x22, %edx
je 0x7453
cmpl $0x28, %edx
je 0x7434
cmpl $0x29, %edx
je 0x746d
cmpl $0x2f, %edx
je 0x7465
cmpl $0x5b, %edx
je 0x7434
cmpl $0x5d, %edx
je 0x7444
testl %edx, %edx
je 0x7488
xorl %ecx, %ecx
cmpl $0xc, %edx
je 0x7481
cmpl $0x40, %edx
jne 0x747a
jmp 0x7481
cmpl $0x63, %ebx
jg 0x747f
movslq %ebx, %rcx
incl %ebx
movb %dl, (%rcx,%r14)
jmp 0x747a
testl %ebx, %ebx
jle 0x747f
decl %ebx
cmpb $0x5b, (%rbx,%r14)
je 0x747a
jmp 0x747f
incq %rax
movq %rax, %rdi
callq 0x47ed
cmpb $0x22, (%rax)
je 0x747a
jmp 0x747f
cmpb $0x2f, 0x1(%rax)
jne 0x747a
jmp 0x747f
testl %ebx, %ebx
jle 0x747f
decl %ebx
cmpb $0x28, (%rbx,%r14)
jne 0x747f
incq %rax
jmp 0x7401
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
sete %cl
jmp 0x7481
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: loopiter(ident*, identstack&, tagval const&)
void loopiter(ident *id, identstack &stack, const tagval &v)
{
    if(id->stack != &stack)
    {
        pusharg(*id, v, stack);
        id->flags &= ~IDF_UNKNOWN;
    }
    else
    {
        if(id->valtype == VAL_STR) delete[] id->val.s;
        cleancode(*id);
        id->setval(v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpq %rsi, 0x28(%rdi)
je 0x7660
movq %rsi, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b34
andb $-0x21, 0x38(%rbx)
jmp 0x768a
cmpl $0x3, 0x10(%rbx)
jne 0x7674
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7674
callq 0xf9a8
movq %rbx, %rdi
callq 0x389a
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setiter(ident&, int, identstack&)
static inline void setiter(ident &id, int i, identstack &stack)
{
    if(i)
    {
        if(id.valtype != VAL_INT)
        {
            if(id.valtype == VAL_STR) delete[] id.val.s;
            cleancode(id);
            id.valtype = VAL_INT;
        }
        id.val.i = i;
    }
    else
    {
        tagval zero;
        zero.setint(0);
        pusharg(id, zero, stack);
        id.flags &= ~IDF_UNKNOWN;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x774d
movl %esi, %r14d
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
je 0x7747
cmpl $0x3, %eax
jne 0x7738
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7738
callq 0xf9a8
movq %rbx, %rdi
callq 0x389a
movl $0x1, 0x10(%rbx)
movl %r14d, 0x20(%rbx)
jmp 0x7767
leaq -0x20(%rbp), %rsi
movl $0x1, 0x8(%rsi)
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x3b34
andb $-0x21, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: loopconc(ident*, int, unsigned int*, bool)
char *loopconc(ident *id, int n, uint *body, bool space)
{
    identstack stack;
    vector<char> s;
    loopi(n)
    {
        setiter(*id, i, stack);
        tagval v;
        executeret(body, v);
        const char *vstr = v.getstr();
        int len = strlen(vstr);
        if(space && i) s.add(' ');
        s.put(vstr, len);
        freearg(v);
    }
    if(n > 0) poparg(*id);
    s.add('\0');
    return newstring(s.getbuf(), s.length()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r14d
movl %esi, -0x44(%rbp)
cmovgl %esi, %r14d
leaq -0x68(%rbp), %r13
xorb $0x1, %cl
movl %ecx, -0x48(%rbp)
cmpl %r15d, %r14d
je 0x78ba
movq -0x50(%rbp), %rdi
movl %r15d, %esi
leaq -0x80(%rbp), %rdx
callq 0x7708
movq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x4b25
movq %r13, %rdi
callq 0xd32c
movq %rax, %rbx
movq %rax, %rdi
callq 0x20a0
movq %rax, %r12
testl %r15d, %r15d
sete %al
orb -0x48(%rbp), %al
jne 0x789e
movb $0x20, -0x29(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xd2d6
movq %r13, %rdi
callq 0x3745
incl %r15d
jmp 0x784b
cmpl $0x0, -0x44(%rbp)
jle 0x78c9
movq -0x50(%rbp), %rdi
callq 0x3b64
leaq -0x68(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
decq %rsi
callq 0xd339
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7911
jmp 0x7911
jmp 0x7911
jmp 0x7911
jmp 0x7911
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: format(tagval*, int)
void format(tagval *args, int numargs)
{
    vector<char> s;
    const char *f = args[0].getstr();
    while(*f)
    {
        int c = *f++;
        if(c == '%')
        {
            int i = *f++;
            if(i >= '1' && i <= '9')
            {
                i -= '0';
                const char *sub = i < numargs ? args[i].getstr() : "";
                while(*sub) s.add(*sub++);
            }
            else s.add(i);
        }
        else s.add(c);
    }
    s.add('\0');
    result(s.getbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
callq 0xd32c
movq %rax, %r15
leaq -0x40(%rbp), %r12
leaq -0x29(%rbp), %r13
movb (%r15), %al
testb %al, %al
je 0x7aa4
cmpb $0x25, %al
jne 0x7a81
movb 0x1(%r15), %al
addq $0x2, %r15
leal -0x31(%rax), %ecx
cmpb $0x8, %cl
ja 0x7a94
movzbl %al, %eax
addl $-0x30, %eax
leaq 0xa2ba(%rip), %rsi      # 0x11d0f
cmpl %ebx, %eax
jge 0x7a6b
movl %eax, %edi
shlq $0x4, %rdi
addq -0x48(%rbp), %rdi
callq 0xd32c
movq %rax, %rsi
cmpb $0x0, (%rsi)
je 0x7a2d
leaq 0x1(%rsi), %r14
movq %r12, %rdi
callq 0xd296
movq %r14, %rsi
jmp 0x7a6b
movb %al, -0x29(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xd296
incq %r15
jmp 0x7a2d
movb %al, -0x29(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xd296
jmp 0x7a2d
leaq -0x29(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq -0x40(%rbp), %rdi
callq 0x44d6
leaq -0x40(%rbp), %rdi
callq 0x36e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7adf
jmp 0x7adf
jmp 0x7adf
jmp 0x7adf
jmp 0x7adf
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: at(tagval*, int)
void at(tagval *args, int numargs)
{
    if(!numargs) return;
    const char *start = args[0].getstr(), *end = start + strlen(start);
    for(int i = 1; i < numargs; i++)
    {
        const char *list = start;
        int pos = args[i].getint();
        for(; pos > 0; pos--) if(!parselist(list)) break; 
        if(pos > 0 || !parselist(list, start, end)) start = end = "";
    }
    commandret->setstr(newstring(start, end-start));
}

// Assembly:
testl %esi, %esi
je 0x7faf
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r12
callq 0xd32c
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq %r14, (%rax)
movq %r14, %rdi
callq 0x20a0
addq %r14, %rax
leaq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movslq %ebx, %rax
movq %rax, -0x48(%rbp)
pushq $0x1
popq %rdi
leaq 0x11cfb(%rip), %r13     # 0x19be8
leaq 0x11cdc(%rip), %r14     # 0x19bd0
leaq 0x11cdd(%rip), %r15     # 0x19bd8
leaq -0x58(%rbp), %rbx
movq %r12, -0x40(%rbp)
cmpq -0x48(%rbp), %rdi
jge 0x7f80
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
shlq $0x4, %rdi
addq %r12, %rdi
callq 0xd240
movl %eax, %r12d
incl %r12d
decl %r12d
movq %rbx, %rdi
testl %r12d, %r12d
jle 0x7f4d
leaq 0x11ca7(%rip), %rsi     # 0x19be0
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x7b77
testb %al, %al
jne 0x7f27
jmp 0x7f64
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x7b77
testb %al, %al
jne 0x7f73
leaq 0x9da4(%rip), %rax      # 0x11d0f
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rdi
incq %rdi
movq -0x40(%rbp), %r12
jmp 0x7f03
movq 0x11299(%rip), %rbx     # 0x19220
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: sublist(char const*, int*, int*, int*)
void sublist(const char *s, int *skip, int *count, int *numargs)
{
    int offset = max(*skip, 0), len = *numargs >= 3 ? max(*count, 0) : -1;
    loopi(offset) if(!parselist(s)) break;
    if(len < 0) { if(offset > 0) skiplist(s); commandret->setstr(newstring(s)); return; }
    const char *list = s, *start, *end, *qstart, *qend = s;
    if(len > 0 && parselist(s, start, end, list, qend)) while(--len > 0 && parselist(s, start, end, qstart, qend));
    commandret->setstr(newstring(list, qend - list)); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x30(%rbp)
movl (%rsi), %esi
cmpl $0x3, (%rcx)
jl 0x804b
movl (%rdx), %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
jmp 0x804e
pushq $-0x1
popq %rbx
xorl %r14d, %r14d
testl %esi, %esi
movl %esi, -0x3c(%rbp)
cmovgl %esi, %r14d
incl %r14d
leaq 0x11b6c(%rip), %r15     # 0x19bd0
leaq 0x11b6d(%rip), %r12     # 0x19bd8
leaq -0x30(%rbp), %r13
decl %r14d
je 0x8094
movq %r13, %rdi
leaq 0x11b62(%rip), %rsi     # 0x19be0
leaq 0x11b63(%rip), %rdx     # 0x19be8
movq %r15, %rcx
movq %r12, %r8
callq 0x7b77
testb %al, %al
jne 0x806f
testl %ebx, %ebx
js 0x810e
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x38(%rbp)
je 0x80f5
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x7b77
testb %al, %al
je 0x80f5
incl %ebx
leaq -0x58(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq -0x60(%rbp), %r12
leaq -0x38(%rbp), %r13
decl %ebx
cmpl $0x2, %ebx
jl 0x80f5
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x7b77
testb %al, %al
jne 0x80d5
movq 0x11124(%rip), %rbx     # 0x19220
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
jmp 0x812d
cmpl $0x0, -0x3c(%rbp)
jle 0x811d
leaq -0x30(%rbp), %rdi
callq 0x8146
movq 0x110fc(%rip), %rbx     # 0x19220
movq -0x30(%rbp), %rdi
callq 0xd0ec
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: skiplist(char const*&)
static inline void skiplist(const char *&p)
{
    for(;;)
    {
        p += strspn(p, " \t\r\n");
        if(p[0]!='/' || p[1]!='/') break;
        p += strcspn(p, "\n\0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x9baa(%rip), %r14      # 0x11d0b
leaq 0x95c5(%rip), %r15      # 0x1172d
movq %r12, %rdi
movq %r14, %rsi
callq 0x2090
leaq (%r12,%rax), %r13
movq %r13, (%rbx)
cmpb $0x2f, (%r12,%rax)
jne 0x819e
cmpb $0x2f, 0x1(%r13)
jne 0x819e
movq %r13, %rdi
movq %r15, %rsi
callq 0x2030
movq %rax, %r12
addq %r13, %r12
movq %r12, (%rbx)
jmp 0x8168
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: listfind(ident*, char const*, unsigned int const*)
void listfind(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) { intret(-1); return; }
    identstack stack;
    int n = -1;
    for(const char *s = list, *start, *end; parselist(s, start, end);)
    {
        ++n;
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);
        if(executebool(body)) { intret(n); goto found; }
    }
    intret(-1);
found:
    if(n >= 0) poparg(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x4, (%rdi)
jne 0x828c
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rsi, (%rax)
pushq $-0x1
popq %r15
leaq -0x38(%rbp), %r12
leaq -0x30(%rbp), %r13
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x11995(%rip), %rcx     # 0x19bd0
leaq 0x11996(%rip), %r8      # 0x19bd8
callq 0x7b77
testb %al, %al
je 0x829f
incl %r15d
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
movq %rbx, %rdi
movq %rax, %rsi
leaq -0x58(%rbp), %rdx
callq 0x82cc
movq %r14, %rdi
callq 0x6fd4
testb %al, %al
je 0x822a
movq 0x10fa0(%rip), %rax     # 0x19220
movl $0x1, 0x8(%rax)
movl %r15d, (%rax)
jmp 0x82b0
movq 0x10f8d(%rip), %rax     # 0x19220
movl $0x1, 0x8(%rax)
orl $-0x1, (%rax)
jmp 0x82bd
movq 0x10f7a(%rip), %rax     # 0x19220
movl $0x1, 0x8(%rax)
orl $-0x1, (%rax)
testl %r15d, %r15d
js 0x82bd
movq %rbx, %rdi
callq 0x3b64
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setiter(ident&, char*, identstack&)
static inline void setiter(ident &id, char *val, identstack &stack)
{
    if(id.stack == &stack)
    {
        if(id.valtype == VAL_STR) delete[] id.val.s;
        else id.valtype = VAL_STR;
        cleancode(id);
        id.val.s = val;
    }
    else
    {
        tagval t;
        t.setstr(val);
        pusharg(id, t, stack);
        id.flags &= ~IDF_UNKNOWN;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdx, 0x28(%rdi)
je 0x82ff
leaq -0x20(%rbp), %rsi
movl $0x3, 0x8(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x3b34
andb $-0x21, 0x38(%rbx)
jmp 0x8328
cmpl $0x3, 0x10(%rbx)
jne 0x8315
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x831c
callq 0xf9a8
jmp 0x831c
movl $0x3, 0x10(%rbx)
movq %rbx, %rdi
callq 0x389a
movq %r14, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: looplist(ident*, char const*, unsigned int const*)
void looplist(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    int n = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);
        execute(body);
    }
    if(n) poparg(*id);
}

// Assembly:
cmpl $0x4, (%rdi)
jne 0x83cb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rsi, (%rax)
xorl %r13d, %r13d
leaq -0x38(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
leaq 0x1185c(%rip), %rcx     # 0x19bd0
leaq 0x1185d(%rip), %r8      # 0x19bd8
callq 0x7b77
testb %al, %al
je 0x83b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
movq %rbx, %rdi
movq %rax, %rsi
leaq -0x58(%rbp), %rdx
callq 0x82cc
movq %r14, %rdi
callq 0x6f03
decl %r13d
jmp 0x8363
testl %r13d, %r13d
je 0x83bd
movq %rbx, %rdi
callq 0x3b64
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: looplistconc(ident*, char const*, unsigned int const*, bool)
void looplistconc(ident *id, const char *list, const uint *body, bool space)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    vector<char> r;
    int n = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, -0x44(%rbp)
cmpl $0x4, (%rdi)
jne 0x84ea
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
leaq -0x60(%rbp), %rax
movq %rsi, (%rax)
xorl %r14d, %r14d
leaq -0x70(%rbp), %r13
leaq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq 0x117b6(%rip), %rcx     # 0x19bd0
leaq 0x117b7(%rip), %r8      # 0x19bd8
callq 0x7b77
testb %al, %al
je 0x84a3
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
movq %rbx, %rdi
movq %rax, %rsi
leaq -0x88(%rbp), %rdx
callq 0x82cc
addl $-0x1, %r14d
setb %al
andb -0x44(%rbp), %al
cmpb $0x1, %al
jne 0x846a
movb $0x20, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0xd296
movq %r15, %rdi
movq %r13, %rsi
callq 0x4b25
movq %r13, %rdi
callq 0xd32c
movq %rax, %r12
movq %rax, %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xd2d6
movq %r13, %rdi
callq 0x3745
jmp 0x8407
testl %r14d, %r14d
je 0x84b0
movq %rbx, %rdi
callq 0x3b64
leaq -0x70(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq 0x10d59(%rip), %rbx     # 0x19220
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
decq %rsi
callq 0xd339
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
leaq -0x40(%rbp), %rdi
callq 0x36e0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8505
jmp 0x8505
jmp 0x8505
jmp 0x8505
jmp 0x8505
jmp 0x8505
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: listfilter(ident*, char const*, unsigned int const*)
void listfilter(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    vector<char> r;
    int n = 0;
    for(const char *s = list, *start, *end, *quotestart, *quoteend; parselist(s, start, end, quotestart, quoteend); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x4, (%rdi)
jne 0x862d
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
leaq -0x48(%rbp), %rax
movq %rsi, (%rax)
xorl %r15d, %r15d
leaq -0x58(%rbp), %r13
leaq -0x50(%rbp), %r12
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x7b77
testb %al, %al
je 0x85e6
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0xd339
movq %rbx, %rdi
movq %rax, %rsi
leaq -0x80(%rbp), %rdx
callq 0x82cc
movq %r14, %rdi
callq 0x6fd4
testb %al, %al
je 0x85e1
cmpl $0x0, -0x34(%rbp)
je 0x85cf
movb $0x20, -0x29(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
subl %esi, %edx
leaq -0x40(%rbp), %rdi
callq 0xd2d6
decl %r15d
jmp 0x8572
testl %r15d, %r15d
je 0x85f3
movq %rbx, %rdi
callq 0x3b64
leaq -0x48(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq 0x10c16(%rip), %rbx     # 0x19220
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
decq %rsi
callq 0xd339
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
leaq -0x40(%rbp), %rdi
callq 0x36e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8642
jmp 0x8642
jmp 0x8642
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: prettylist(char const*, char const*)
void prettylist(const char *s, const char *conj)
{
    vector<char> p;
    const char *start, *end;
    for(int len = listlen(s), n = 0; parselist(s, start, end); n++)
    {
        p.put(start, end - start);
        if(n+1 < len)
        {
            if(len > 2 || !conj[0]) p.add(',');
            if(n+2 == len && conj[0])
            {
                p.add(' ');
                p.put(conj, strlen(conj));
            }
            p.add(' ');
        }
    } 
    p.add('\0');
    result(p.getbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq -0x58(%rbp), %rax
movq %rdi, (%rax)
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, (%r15)
callq 0x7e1e
movl %eax, %r12d
pushq $0x2
popq %r13
subl %eax, %r13d
pushq $0x1
popq %r14
leaq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq 0x1152e(%rip), %rcx     # 0x19bd0
leaq 0x1152f(%rip), %r8      # 0x19bd8
callq 0x7b77
testb %al, %al
je 0x872e
movq -0x50(%rbp), %rsi
movl -0x48(%rbp), %edx
subl %esi, %edx
movq %r15, %rdi
callq 0xd2d6
cmpl %r12d, %r14d
jge 0x8726
cmpl $0x2, %r12d
jg 0x86d3
cmpb $0x0, (%rbx)
jne 0x86e3
movb $0x2c, -0x29(%rbp)
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
leal (%r14,%r13), %eax
cmpl $0x1, %eax
jne 0x8716
cmpb $0x0, (%rbx)
je 0x8716
movb $0x20, -0x29(%rbp)
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
movq %rbx, %rdi
callq 0x20a0
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xd2d6
movb $0x20, -0x29(%rbp)
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
incl %r14d
jmp 0x868f
leaq -0x29(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq -0x40(%rbp), %rdi
callq 0x44d6
leaq -0x40(%rbp), %rdi
callq 0x36e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8769
jmp 0x8769
jmp 0x8769
jmp 0x8769
jmp 0x8769
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: listincludes(char const*, char const*, int)
int listincludes(const char *list, const char *needle, int needlelen)
{
    int offset = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end);)
    {
        int len = end - start;
        if(needlelen == len && !strncmp(needle, start, len)) return offset;
        offset++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rdi, (%rax)
xorl %r15d, %r15d
leaq 0x11433(%rip), %r12     # 0x19bd8
leaq -0x40(%rbp), %r14
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
leaq 0x11412(%rip), %rcx     # 0x19bd0
movq %r12, %r8
callq 0x7b77
testb %al, %al
je 0x87ee
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rsi
subq %rsi, %rax
cmpl %ebx, %eax
jne 0x87e9
movslq %eax, %rdx
movq -0x30(%rbp), %rdi
callq 0x20c0
testl %eax, %eax
je 0x87f3
incl %r15d
jmp 0x87ad
pushq $-0x1
popq %rax
jmp 0x87f6
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop