LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5181
movl (%rdi), %eax
testb $0x3f, %al
je 0x5183
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1, %ecx
je 0x5197
testl %ecx, %ecx
jne 0x5181
addq $-0x4, %rdi
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jl 0x5191
popq %rbp
retq
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jge 0x5181
popq %rbp
jmp 0x152d7
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
addl (%rdi), %eax
movl %eax, (%rdi)
cmpl $0xff, %eax
jg 0x5181
jmp 0x5191
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51cb
testb $0x4, 0x38(%rdi)
jne 0x51d8
leaq 0x11b7b(%rip), %rax     # 0x16d44
jmp 0x5216
movq 0x8(%rdi), %rsi
leaq 0x11b6e(%rip), %rdi     # 0x16d44
jmp 0x521d
cmpl $0xffffff, 0x18(%rdi)   # imm = 0xFFFFFF
jne 0x520f
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 0x11b45(%rip), %rdi     # 0x16d4c
xorl %eax, %eax
popq %rbp
jmp 0x35fb
leaq 0x11b4f(%rip), %rax     # 0x16d65
movq 0x8(%rdi), %rsi
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x35fb
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x52db
cmpl $0x1, %eax
je 0x52bb
testl %eax, %eax
jne 0x5316
movq 0x20(%rbx), %rax
movl (%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51b2
movq 0x8(%rbx), %r14
movq 0x20(%rbx), %rax
movss (%rax), %xmm0
callq 0x4d63
leaq 0x11a9c(%rip), %rdi     # 0x16d6f
movq %r14, %rsi
movq %rax, %rdx
jmp 0x530b
movq 0x20(%rbx), %rax
movq (%rax), %r14
movq %r14, %rdi
movl $0x22, %esi
callq 0x2060
testq %rax, %rax
leaq 0x11a88(%rip), %rax     # 0x16d81
leaq 0x11a77(%rip), %rdi     # 0x16d77
cmoveq %rax, %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x35fb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %esi
addl $0x40, %esi
cmpl -0x18(%rbp), %esi
jle 0x8c2f
leaq -0x20(%rbp), %rdi
callq 0x12c74
leaq -0x20(%rbp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x50ab
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x531b
movq -0x20(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x8c63
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8c78
callq 0x152d7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8c83
movq %rax, %rbx
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8c9b
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x531b
cmpl $0x0, 0x8(%rbx)
je 0x8ccb
movq %rbx, %rdi
callq 0x8cd4
movq (%rbx), %rax
jmp 0x8ccd
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leaq 0xe41f(%rip), %r14      # 0x1710f
decl %eax
cmpl $0x5, %eax
ja 0x8d6b
leaq 0xd92a(%rip), %rcx      # 0x16628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %r14
jmp 0x8dc3
movss (%rbx), %xmm0
callq 0x4d63
movq %rax, %r14
jmp 0x8d6b
movl (%rbx), %edx
movl 0x15a6f(%rip), %eax     # 0x1e794
incl %eax
andl $0x3, %eax
movl %eax, 0x15a64(%rip)     # 0x1e794
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq 0x15a61(%rip), %r15     # 0x1e7a0
addq %r15, %rax
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xdff1(%rip), %rsi      # 0x16d41
xorl %eax, %eax
callq 0x128d0
movl 0x15a37(%rip), %eax     # 0x1e794
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
movl 0x8(%rbx), %eax
cmpl $0x5, %eax
je 0x8d82
cmpl $0x3, %eax
jne 0x8d94
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x8d8f
jmp 0x8d94
movq (%rbx), %rdi
cmpl $0x0, -0x4(%rdi)
jne 0x8d94
addq $-0x4, %rdi
callq 0x152d7
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x152b1
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
movl $0x3, 0x8(%rbx)
movq %r12, (%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c03
cmpl $0x0, 0x8(%rbx)
je 0x8dfb
movq %rbx, %rdi
callq 0x8cd4
movq (%rbx), %rax
jmp 0x8dfd
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq %r14, %rsi
callq 0x531b
xorl %ebx, %ebx
movl 0x8(%r14), %eax
decl %eax
cmpl $0x5, %eax
ja 0x8e54
leaq 0xd811(%rip), %rcx      # 0x16640
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
movq %rax, %rbx
jmp 0x8e54
cvttss2si -0x20(%rbp), %ebx
jmp 0x8e54
movl -0x20(%rbp), %ebx
movl -0x18(%rbp), %eax
cmpl $0x5, %eax
je 0x8e6c
cmpl $0x3, %eax
jne 0x8e7f
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
jne 0x8e7a
jmp 0x8e7f
movq -0x20(%rbp), %rdi
cmpl $0x0, -0x4(%rdi)
jne 0x8e7f
addq $-0x4, %rdi
callq 0x152d7
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %esi
addl $0x40, %esi
cmpl -0x18(%rbp), %esi
jle 0x8eb1
leaq -0x20(%rbp), %rdi
callq 0x12c74
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x50ab
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
leaq -0x30(%rbp), %rsi
callq 0x531b
movq -0x20(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x8ee6
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
xorl %ebx, %ebx
movl -0x28(%rbp), %eax
decl %eax
cmpl $0x5, %eax
ja 0x8f1e
leaq 0xd75f(%rip), %rcx      # 0x16658
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
movq %rax, %rbx
jmp 0x8f1e
cvttss2si -0x30(%rbp), %ebx
jmp 0x8f1e
movl -0x30(%rbp), %ebx
movl -0x28(%rbp), %eax
cmpl $0x5, %eax
je 0x8f36
cmpl $0x3, %eax
jne 0x8f49
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
jne 0x8f44
jmp 0x8f49
movq -0x30(%rbp), %rdi
cmpl $0x0, -0x4(%rdi)
jne 0x8f49
addq $-0x4, %rdi
callq 0x152d7
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8f5e
callq 0x152d7
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x8f6b
jmp 0x8f6b
movq %rax, %rbx
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8f83
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq %r14, %rsi
callq 0x531b
movq %r14, %rdi
callq 0x8fe3
movl %eax, %ebx
movl 0x8(%r14), %eax
cmpl $0x5, %eax
je 0x8fc5
cmpl $0x3, %eax
jne 0x8fd8
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
jne 0x8fd3
jmp 0x8fd8
movq -0x20(%rbp), %rdi
cmpl $0x0, -0x4(%rdi)
jne 0x8fd8
addq $-0x4, %rdi
callq 0x152d7
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl 0x8(%rdi), %ecx
xorl %eax, %eax
decl %ecx
cmpl $0x5, %ecx
ja 0x90cd
leaq 0xd66d(%rip), %rdx      # 0x16670
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rbx
movzbl (%rbx), %ecx
leal -0x2b(%rcx), %eax
cmpl $0x5, %eax
ja 0x9087
leaq 0xd667(%rip), %rcx      # 0x16688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0x1(%rbx), %ecx
cmpl $0x30, %ecx
je 0x905d
movb $0x1, %al
cmpl $0x2e, %ecx
jne 0x90cd
movsbl 0x2(%rbx), %ecx
addl $-0x30, %ecx
jmp 0x909c
xorps %xmm0, %xmm0
cmpneqss (%rdi), %xmm0
movd %xmm0, %eax
jmp 0x90ca
cmpl $0x0, (%rdi)
setne %al
jmp 0x90cd
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2050
movq %rax, %rcx
movb $0x1, %al
testl %ecx, %ecx
jne 0x90cd
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x65, %eax
je 0x90a1
cmpl $0x2e, %eax
je 0x90a1
jmp 0x908b
testl %ecx, %ecx
jne 0x908f
xorl %eax, %eax
jmp 0x90cd
movb $0x1, %al
jmp 0x90cd
movsbl 0x1(%rbx), %ecx
addl $-0x30, %ecx
movb $0x1, %al
cmpl $0x9, %ecx
ja 0x90cd
leaq -0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x2120
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x90b9
jnp 0x90d4
cvtsd2ss %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpneqss %xmm0, %xmm1
movd %xmm1, %eax
andl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq -0x10(%rbp), %rax
cmpq %rbx, %rax
je 0x90b9
movzbl (%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x90b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
jmp 0x90bd
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq %r14, %rsi
callq 0x8c03
movq %r14, %rdi
callq 0x8fe3
movl %eax, %ebx
movl 0x8(%r14), %eax
cmpl $0x5, %eax
je 0x9137
cmpl $0x3, %eax
jne 0x914a
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
jne 0x9145
jmp 0x914a
movq -0x20(%rbp), %rdi
cmpl $0x0, -0x4(%rdi)
jne 0x914a
addq $-0x4, %rdi
callq 0x152d7
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14d
movq %rdi, %rbx
callq 0x2080
movq %rax, %r15
incq %r15
movl $0x104, %eax            # imm = 0x104
cmpq %rax, %r15
cmovaeq %rax, %r15
leaq -0x130(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2130
movb $0x0, -0x131(%rbp,%r15)
movq %r12, %rdi
callq 0x13788
movq %rax, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1477a
movq %rax, %r15
testq %rax, %rax
je 0x91fd
movq 0x15510(%rip), %r14     # 0x1e6d8
movq 0x15511(%rip), %r12     # 0x1e6e0
movq %rbx, 0x15502(%rip)     # 0x1e6d8
movq %r15, 0x15503(%rip)     # 0x1e6e0
movq %r15, %rdi
callq 0x8e8a
movq %r14, 0x154ec(%rip)     # 0x1e6d8
movq %r12, 0x154ed(%rip)     # 0x1e6e0
movq %r15, %rdi
callq 0x152d7
jmp 0x9218
testb %r14b, %r14b
je 0x9218
leaq 0xdb82(%rip), %rsi      # 0x16d8b
movl $0x4, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3676
testq %r15, %r15
setne %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x154b3(%rip), %al      # 0x1e720
testb %al, %al
je 0x936a
movl 0x154ad(%rip), %eax     # 0x1e728
movl %eax, %ecx
incl %ecx
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
imulq %rcx, %rdx
shrq $0x21, %rdx
leal (%rdx,%rdx,2), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x1548d(%rip)     # 0x1e728
shll $0x4, %eax
leaq 0x1544b(%rip), %rcx     # 0x1e6f0
leaq (%rcx,%rax), %r14
movl $0x0, 0xc(%rax,%rcx)
leaq -0x29(%rbp), %rsi
movb $0x22, (%rsi)
movq %r14, %rdi
callq 0x12760
leaq 0xdae6(%rip), %r13      # 0x16dad
leaq 0xdae2(%rip), %r15      # 0x16db0
leaq 0xdade(%rip), %r12      # 0x16db3
movzbl (%rbx), %eax
cmpl $0xb, %eax
jle 0x92f4
cmpl $0xc, %eax
je 0x930a
cmpl $0x22, %eax
je 0x9312
cmpl $0x5e, %eax
jne 0x9337
movq %r14, %rdi
movq %r12, %rsi
jmp 0x9324
cmpl $0x9, %eax
je 0x931a
cmpl $0xa, %eax
jne 0x9333
movq %r14, %rdi
leaq 0xda9f(%rip), %rsi      # 0x16da7
jmp 0x9324
movq %r14, %rdi
movq %r13, %rsi
jmp 0x9324
movq %r14, %rdi
movq %r15, %rsi
jmp 0x9324
movq %r14, %rdi
leaq 0xda86(%rip), %rsi      # 0x16daa
movl $0x2, %edx
callq 0x1279e
incq %rbx
jmp 0x92d5
testl %eax, %eax
je 0x9344
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12760
jmp 0x932e
leaq 0xd775(%rip), %rsi      # 0x16ac0
movq %r14, %rdi
movl $0x2, %edx
callq 0x1279e
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2400
jmp 0x9275
// File: /workspace/github_cpp_makefile_star2_O1/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 0x152b4(%rip), %r14     # 0x1e730
movb (%rax), %sil
movzbl %sil, %edx
xorl %ecx, %ecx
cmpl $0x2e, %edx
jg 0x94a8
cmpl $0x27, %edx
jle 0x94c7
cmpl $0x28, %edx
je 0x94b7
cmpl $0x29, %edx
jne 0x950a
testl %ebx, %ebx
jle 0x9512
decl %ebx
cmpb $0x28, (%rbx,%r14)
je 0x950a
jmp 0x9512
cmpl $0x5a, %edx
jle 0x94de
cmpl $0x5d, %edx
je 0x94eb
cmpl $0x5b, %edx
jne 0x950a
cmpl $0x63, %ebx
jg 0x9512
movslq %ebx, %rcx
incl %ebx
movb %sil, (%rcx,%r14)
jmp 0x950a
cmpl $0x22, %edx
jne 0x94fa
incq %rax
movq %rax, %rdi
callq 0x4f5c
cmpb $0x22, (%rax)
je 0x950a
jmp 0x9512
cmpl $0x2f, %edx
jne 0x9505
cmpb $0x2f, 0x1(%rax)
jne 0x950a
jmp 0x9512
testl %ebx, %ebx
jle 0x9512
decl %ebx
cmpb $0x5b, (%rbx,%r14)
je 0x950a
jmp 0x9512
testl %edx, %edx
je 0x951b
cmpl $0xc, %edx
jne 0x950a
jmp 0x9514
cmpl $0x40, %edx
je 0x9514
incq %rax
jmp 0x947c
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
sete %cl
jmp 0x9514
// File: /workspace/github_cpp_makefile_star2_O1/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 0x978b
movq 0x20(%rbx), %rax
movq %rax, (%rsi)
movl 0x10(%rbx), %eax
movl %eax, 0x8(%rsi)
movq 0x28(%rbx), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x28(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x9785
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x977d
callq 0x152d7
movq $0x0, 0x18(%rbx)
andb $-0x21, 0x38(%rbx)
jmp 0x97d5
cmpl $0x3, 0x10(%rbx)
jne 0x979f
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x979f
callq 0x152d7
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x97c7
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x97bf
callq 0x152d7
movq $0x0, 0x18(%rbx)
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_O1/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 0xaa10
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movl 0x8(%rdi), %eax
leaq 0xc8d8(%rip), %r14      # 0x1710f
decl %eax
cmpl $0x5, %eax
movq %rdi, -0x40(%rbp)
ja 0xa8b3
leaq 0xbec7(%rip), %rcx      # 0x16710
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %r14
jmp 0xa8b3
movss (%rdi), %xmm0
callq 0x4d63
movq %rax, %r14
jmp 0xa8b3
movl (%rdi), %edx
movl 0x13f27(%rip), %eax     # 0x1e794
incl %eax
andl $0x3, %eax
movl %eax, 0x13f1c(%rip)     # 0x1e794
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq 0x13f19(%rip), %r15     # 0x1e7a0
addq %r15, %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xc4a9(%rip), %rsi      # 0x16d41
xorl %eax, %eax
callq 0x128d0
movl 0x13eef(%rip), %eax     # 0x1e794
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
movq %r14, -0x30(%rbp)
movq %r14, %rdi
callq 0x2080
movq -0x40(%rbp), %rdx
addq %r14, %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, %ebx
jl 0xa9ad
movl %ebx, %eax
movq %rax, -0x48(%rbp)
movl $0x1, %r15d
leaq 0x142da(%rip), %r12     # 0x1ebc0
leaq 0x142db(%rip), %r13     # 0x1ebc8
leaq -0x50(%rbp), %rbx
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %r15, %rax
shlq $0x4, %rax
movl 0x8(%rdx,%rax), %ecx
decl %ecx
movl $0x0, %r14d
cmpl $0x5, %ecx
ja 0xa942
addq %rdx, %rax
leaq 0xbe0d(%rip), %rdx      # 0x16728
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
xorl %r14d, %r14d
jmpq *%rcx
movq (%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
movq %rax, %r14
jmp 0xa942
cvttss2si (%rax), %r14d
jmp 0xa942
movl (%rax), %r14d
testl %r14d, %r14d
jle 0xa973
incl %r14d
movq %rbx, %rdi
leaq 0x1427c(%rip), %rsi     # 0x1ebd0
leaq 0x1427d(%rip), %rdx     # 0x1ebd8
movq %r12, %rcx
movq %r13, %r8
callq 0xa23b
testb %al, %al
je 0xa98d
decl %r14d
cmpl $0x2, %r14d
jge 0xa94a
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0xa23b
testb %al, %al
jne 0xa99c
leaq 0xc77b(%rip), %rax      # 0x1710f
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
incq %r15
cmpq -0x48(%rbp), %r15
movq -0x40(%rbp), %rdx
jne 0xa8f1
movq 0x13854(%rip), %r13     # 0x1e208
movq -0x30(%rbp), %rbx
movq -0x38(%rbp), %r14
subq %rbx, %r14
incq %r14
movq %r14, %rdi
callq 0x152b1
movq %rax, %r15
movq %rbx, %rdi
callq 0x2080
movq %rax, %r12
incq %r12
cmpq %r14, %r12
cmovaeq %r14, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2130
movb $0x0, -0x1(%r15,%r12)
movl $0x3, 0x8(%r13)
movq %r15, (%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, (%rcx)
jl 0xaae6
movl (%rdx), %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
movq %rsi, -0x40(%rbp)
testl %esi, %esi
jle 0xab33
movq -0x40(%rbp), %rax
leal -0x1(%rax), %r14d
leaq 0x140c3(%rip), %r15     # 0x1ebc0
leaq 0x140c4(%rip), %r12     # 0x1ebc8
leaq -0x30(%rbp), %r13
movq %r13, %rdi
leaq 0x140be(%rip), %rsi     # 0x1ebd0
leaq 0x140bf(%rip), %rdx     # 0x1ebd8
movq %r15, %rcx
movq %r12, %r8
callq 0xa23b
addl $-0x1, %r14d
setb %cl
testb %al, %al
je 0xab33
testb %cl, %cl
jne 0xab08
testl %ebx, %ebx
js 0xabf2
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x38(%rbp)
je 0xab98
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0xa23b
testb %al, %al
je 0xab98
incl %ebx
leaq -0x58(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq -0x60(%rbp), %r12
leaq -0x38(%rbp), %r13
decl %ebx
cmpl $0x2, %ebx
jl 0xab98
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0xa23b
testb %al, %al
jne 0xab78
movq 0x13669(%rip), %r13     # 0x1e208
movq -0x48(%rbp), %rbx
movq -0x38(%rbp), %r14
subq %rbx, %r14
incq %r14
movq %r14, %rdi
callq 0x152b1
movq %rax, %r15
movq %rbx, %rdi
callq 0x2080
movq %rax, %r12
incq %r12
cmpq %r14, %r12
cmovaeq %r14, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2130
movb $0x0, -0x1(%r15,%r12)
movl $0x3, 0x8(%r13)
movq %r15, (%r13)
jmp 0xac9a
cmpl $0x0, -0x40(%rbp)
jle 0xac5d
movq -0x30(%rbp), %rbx
leaq 0xc508(%rip), %rsi      # 0x1710b
movq %rbx, %rdi
callq 0x2070
leaq (%rbx,%rax), %r15
movq %r15, -0x30(%rbp)
cmpb $0x2f, (%rbx,%rax)
jne 0xac5d
leaq 0xbeb9(%rip), %rbx      # 0x16ad9
leaq 0xc4e4(%rip), %r14      # 0x1710b
cmpb $0x2f, 0x1(%r15)
jne 0xac5d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2030
movq %rax, %r12
addq %r15, %r12
movq %r12, -0x30(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2070
leaq (%r12,%rax), %r15
movq %r15, -0x30(%rbp)
cmpb $0x2f, (%rax,%r12)
je 0xac27
movq 0x135a4(%rip), %r12     # 0x1e208
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2080
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x152b1
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movl $0x3, 0x8(%r12)
movq %r15, (%r12)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: looplist(ident*, char const*, unsigned int const*)
void looplist(ident *id, const char *list, const uint *body)
{
    if(id->type!=ID_ALIAS) return;
    identstack stack;
    int n = 0;
    for(const char *s = list, *start, *end; parselist(s, start, end); n++)
    {
        char *val = newstring(start, end-start);
        setiter(*id, val, stack);
        execute(body);
    }
    if(n) poparg(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x48(%rbp)
cmpl $0x4, (%rdi)
jne 0xb0d6
movq %rdi, %rbx
leaq -0x50(%rbp), %rdi
movq %rsi, (%rdi)
leaq 0x13c82(%rip), %rcx     # 0x1ebc0
leaq 0x13c83(%rip), %r8      # 0x1ebc8
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa23b
testb %al, %al
je 0xb0d6
movb %al, -0x29(%rbp)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
subq %r12, %r13
incq %r13
movq %r13, %rdi
callq 0x152b1
movq %rax, %r15
movq %r12, %rdi
callq 0x2080
movq %rax, %r14
incq %r14
cmpq %r13, %r14
jb 0xaf8c
movq %r13, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2130
movb $0x0, -0x1(%r15,%r14)
movq 0x28(%rbx), %rax
leaq -0x68(%rbp), %rdx
cmpq %rdx, %rax
je 0xaffc
movq 0x20(%rbx), %rcx
movq %rcx, -0x68(%rbp)
movl 0x10(%rbx), %ecx
movl %ecx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq %rdx, 0x28(%rbx)
movl $0x3, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xaff6
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0xafee
callq 0x152d7
movq $0x0, 0x18(%rbx)
andb $-0x21, 0x38(%rbx)
jmp 0xb045
cmpl $0x3, 0x10(%rbx)
jne 0xb012
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xb019
callq 0x152d7
jmp 0xb019
movl $0x3, 0x10(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xb041
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0xb039
callq 0x152d7
movq $0x0, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq -0x48(%rbp), %rdi
callq 0x8e04
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq 0x13b5f(%rip), %rcx     # 0x1ebc0
leaq 0x13b60(%rip), %r8      # 0x1ebc8
callq 0xa23b
testb %al, %al
jne 0xaf5d
cmpb $0x0, -0x29(%rbp)
je 0xb0d6
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0xb0d6
cmpl $0x3, 0x10(%rbx)
jne 0xb098
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xb098
callq 0x152d7
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xb0ce
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0xb0c6
callq 0x152d7
movq $0x0, 0x18(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x28(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x48(%rbp)
movq %rdi, -0x60(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leaq 0x13448(%rip), %r15     # 0x1ebd0
leaq 0x13449(%rip), %r12     # 0x1ebd8
leaq 0x1342a(%rip), %r13     # 0x1ebc0
leaq 0x1342b(%rip), %rbx     # 0x1ebc8
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0xa23b
incl %r14d
testb %al, %al
jne 0xb79d
leaq 0x13400(%rip), %rcx     # 0x1ebc0
leaq 0x13401(%rip), %r8      # 0x1ebc8
leaq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xa23b
testb %al, %al
je 0xb8a5
movl $0x2, %r15d
leaq -0x40(%rbp), %rbx
leaq -0x30(%rbp), %r12
leaq 0x133cb(%rip), %r13     # 0x1ebc0
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
subl %esi, %edx
movq %rbx, %rdi
callq 0x1279e
leal -0x1(%r15), %eax
cmpl %r14d, %eax
jae 0xb87f
cmpl $0x2, %r14d
ja 0xb81e
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb82d
movb $0x2c, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12760
cmpl %r15d, %r14d
jne 0xb870
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb870
movb $0x20, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %r13
movq %r12, %rsi
callq 0x12760
movq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1279e
movq %r13, %r12
leaq 0x13350(%rip), %r13     # 0x1ebc0
movb $0x20, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12760
leaq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %r13, %rcx
leaq 0x13333(%rip), %r8      # 0x1ebc8
callq 0xa23b
incl %r15d
testb %al, %al
jne 0xb7f5
leaq -0x30(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12760
movq -0x40(%rbp), %rbx
movq 0x12948(%rip), %r12     # 0x1e208
movq %rbx, %rdi
callq 0x2080
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x152b1
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movl $0x3, 0x8(%r12)
movq %r15, (%r12)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xb909
callq 0x152d7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb922
jmp 0xb922
jmp 0xb922
jmp 0xb922
jmp 0xb922
movq %rax, %rbx
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xb93a
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x38(%rbp)
leaq -0x50(%rbp), %r15
movq %rdi, (%r15)
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
leaq 0x13245(%rip), %rcx     # 0x1ebc0
leaq 0x13246(%rip), %r8      # 0x1ebc8
callq 0xa23b
testb %al, %al
je 0xb9bd
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rsi
subq %rsi, %rax
cmpl %ebx, %eax
jne 0xb9aa
movslq %eax, %rdx
movq -0x38(%rbp), %rdi
callq 0x20a0
testl %eax, %eax
je 0xb9b5
incl %r13d
movb $0x1, %al
testb %al, %al
jne 0xb96b
jmp 0xb9c4
xorl %eax, %eax
movl %r13d, -0x2c(%rbp)
jmp 0xb9af
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: listdel(char const*, char const*)
char *listdel(const char *s, const char *del)
{
    vector<char> p;
    for(const char *start, *end, *qstart, *qend; parselist(s, start, end, qstart, qend);)
    {
        if(listincludes(del, start, end-start) < 0)
        {
            if(!p.empty()) p.add(' ');
            p.put(qstart, qend-qstart);
        }
    }
    p.add('\0');
    return newstring(p.getbuf(), p.length()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq -0x68(%rbp), %rax
movq %rdi, (%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rcx
leaq -0x50(%rbp), %r8
movq %rax, %rdi
callq 0xa23b
testb %al, %al
je 0xbab2
leaq -0x48(%rbp), %r13
leaq -0x60(%rbp), %r15
leaq -0x58(%rbp), %r14
leaq -0x50(%rbp), %r12
movq -0x48(%rbp), %rsi
movl -0x60(%rbp), %edx
subl %esi, %edx
movq %rbx, %rdi
callq 0xb942
testl %eax, %eax
jns 0xba99
cmpl $0x0, -0x34(%rbp)
je 0xba87
movb $0x20, -0x29(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0x12760
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
subl %esi, %edx
leaq -0x40(%rbp), %rdi
callq 0x1279e
leaq -0x68(%rbp), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0xa23b
testb %al, %al
jne 0xba5b
leaq -0x48(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x12760
movq -0x40(%rbp), %rbx
movslq -0x34(%rbp), %r15
movq %r15, %rdi
callq 0x152b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2080
movq %rax, %r12
incq %r12
cmpq %r15, %r12
cmovaeq %r15, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2130
movb $0x0, -0x1(%r14,%r12)
movl $0x0, -0x34(%rbp)
testq %rbx, %rbx
je 0xbb12
movq %rbx, %rdi
callq 0x152d7
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb2a
jmp 0xbb2a
jmp 0xbb2a
movq %rax, %rbx
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xbb42
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: strreplace(char const*, char const*, char const*)
char *strreplace(const char *s, const char *oldval, const char *newval)
{
    vector<char> buf;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, %r13
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rsi, %rdi
callq 0x2080
testl %eax, %eax
je 0xd9dc
cltq
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %r12
movq %r13, -0x50(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x2040
movq %rax, %r14
testq %rax, %rax
je 0xd94b
cmpq %r14, %r15
jae 0xd9ab
leaq 0x1(%r15), %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x12760
movq %rbx, %r15
jmp 0xd91c
leaq 0x1(%r15), %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x12760
movq %rbx, %r15
cmpb $0x0, (%r15)
jne 0xd939
movb $0x0, -0x29(%rbp)
movq %r12, %rdi
leaq -0x29(%rbp), %rsi
callq 0x12760
movq -0x40(%rbp), %rbx
movslq -0x34(%rbp), %r13
incq %r13
movq %r13, %rdi
callq 0x152b1
movq %rax, -0x48(%rbp)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rsi
movq %rax, %rbx
incq %rbx
cmpq %r13, %rbx
cmovaeq %r13, %rbx
movq -0x48(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rdx
callq 0x2130
movb $0x0, -0x1(%r13,%rbx)
movq -0x50(%rbp), %r13
jmp 0xd9d1
movq -0x60(%rbp), %rbx
cmpb $0x0, (%rbx)
je 0xd9c9
movq %r12, %rdi
movq %rbx, %rsi
callq 0x12760
cmpb $0x0, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
jne 0xd9b4
movq -0x58(%rbp), %rax
leaq (%r14,%rax), %r15
testq %r14, %r14
jne 0xd909
jmp 0xda04
movq %r15, %rdi
callq 0x2080
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x152b1
movq %rax, -0x48(%rbp)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2130
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xda19
callq 0x152d7
movq -0x48(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda36
jmp 0xda36
jmp 0xda36
jmp 0xda36
jmp 0xda36
movq %rax, %rbx
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xda4e
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: debugalias()
static void debugalias()
{
    if(!dbgalias) return;
    int total = 0, depth = 0;
    for(identlink *l = aliasstack; l != &noalias; l = l->next) total++;
    for(identlink *l = aliasstack; l != &noalias; l = l->next)
    {
        ident *id = l->id;
        ++depth;
        if(depth < dbgalias) conoutf(CON_ERROR, "  %d) %s", total-depth+1, id->name);
        else if(l->next == &noalias) conoutf(CON_ERROR, depth == dbgalias ? "  %d) %s" : "  ..%d) %s", total-depth+1, id->name);
    }
}

// Assembly:
cmpl $0x0, 0x10c40(%rip)     # 0x1e6c0
je 0xdb1d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10775(%rip), %rax     # 0x1e210
leaq 0x10776(%rip), %r14     # 0x1e218
xorl %ebx, %ebx
cmpq %r14, %rax
je 0xdab1
incl %ebx
movq 0x8(%rax), %rax
jmp 0xdaa4
movq 0x10758(%rip), %r15     # 0x1e210
cmpq %r14, %r15
je 0xdb0f
movl $0x1, %r12d
leaq 0x955a(%rip), %r13      # 0x17024
movq (%r15), %rax
movl 0x10bed(%rip), %ecx     # 0x1e6c0
movq %r13, %rsi
cmpl %ecx, %r12d
jl 0xdaef
cmpq %r14, 0x8(%r15)
jne 0xdb01
cmpl %ecx, %r12d
leaq 0x9542(%rip), %rsi      # 0x1702d
cmoveq %r13, %rsi
movq 0x8(%rax), %rcx
movl $0x4, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3676
movq 0x8(%r15), %r15
decl %ebx
incl %r12d
cmpq %r14, %r15
jne 0xdaca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: setarg(ident&, tagval&)
static inline void setarg(ident &id, tagval &v)
{
    if(aliasstack->usedargs&(1<<id.index))
    {
        if(id.valtype == VAL_STR) delete[] id.val.s;
        id.setval(v);
        cleancode(id);
    }
    else
    {
        pusharg(id, v, aliasstack->argstack[id.index]);
        aliasstack->usedargs |= 1<<id.index;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x106de(%rip), %rax     # 0x1e210
movl 0x10(%rax), %edx
movslq 0x3c(%rdi), %rcx
btl %ecx, %edx
jae 0xdb8e
cmpl $0x3, 0x10(%rbx)
jne 0xdb52
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xdb52
callq 0x152d7
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xdbfd
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0xdb84
callq 0x152d7
movq $0x0, 0x18(%rbx)
jmp 0xdbfd
movq 0x18(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq 0x20(%rbx), %rcx
movq %rcx, (%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x28(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xdbe9
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0xdbe1
callq 0x152d7
movq $0x0, 0x18(%rbx)
movb 0x3c(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x10616(%rip), %rcx     # 0x1e210
orl %eax, 0x10(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: compileblock(vector<unsigned int>&)
static inline void compileblock(vector<uint> &code)
{
    int start = code.length();
    code.add(CODE_BLOCK);
    code.add(CODE_OFFSET|((start+2)<<8));
    code.add(CODE_EXIT);
    code[start] |= uint(code.length() - (start + 1))<<8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq 0xc(%rdi), %r14
leaq -0x1c(%rbp), %rsi
movl $0x9, (%rsi)
callq 0x12c34
movl %r14d, %eax
shll $0x8, %eax
addl $0x201, %eax            # imm = 0x201
leaq -0x18(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x12c34
leaq -0x14(%rbp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x12c34
movl %r14d, %eax
notl %eax
addl 0xc(%rbx), %eax
shll $0x8, %eax
movq (%rbx), %rcx
orl %eax, (%rcx,%r14,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: debugcodeline(char const*, char const*, ...)
static void debugcodeline(const char *p, const char *fmt, ...)
{
    if(nodebug) return;

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

    debugalias();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x10262
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
movq %r9, -0xd8(%rbp)
cmpl $0x0, 0xe443(%rip)      # 0x1e6c8
jne 0x1038c
movq %rsi, %rbx
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x50(%rbp)
movq 0xe42a(%rip), %r13      # 0x1e6e0
testq %r13, %r13
je 0x10376
movq %rdi, %r14
movl $0x1, %r15d
leaq -0x30(%rbp), %r12
movq %r13, %rdi
movl $0xa, %esi
callq 0x2060
testq %rax, %rax
jne 0x102e9
movq %r13, %rdi
callq 0x2080
addq %r13, %rax
cmpq %r14, %r13
seta %cl
cmpq %r14, %rax
setb %dl
orb %cl, %dl
je 0x1030b
cmpb $0x0, (%rax)
je 0x1033b
incq %rax
incl %r15d
xorl %ecx, %ecx
movq %rax, %r13
jmp 0x10362
movq 0xe3c6(%rip), %rdx      # 0x1e6d8
leaq 0xe997(%rip), %rax      # 0x1ecb0
testq %rdx, %rdx
je 0x10342
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq 0x6d85(%rip), %rsi      # 0x170b1
movl %r15d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x128d0
jmp 0x1035d
movl $0x2, %ecx
jmp 0x10362
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq 0x6d64(%rip), %rsi      # 0x170b4
movl %r15d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x128d0
movl $0x1, %ecx
testl %ecx, %ecx
je 0x102cc
cmpl $0x2, %ecx
je 0x10376
leaq 0xe93a(%rip), %rbx      # 0x1ecb0
leaq -0x50(%rbp), %rdx
movl $0x4, %edi
movq %rbx, %rsi
callq 0x35eb
callq 0xda79
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: cutword(char const*&, int&)
static inline char *cutword(const char *&p, int &len)
{
    const char *word = p;
    p = parseword(p);
    len = p-word;
    if(!len) return NULL;
    return newstring(word, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq (%rdi), %rcx
xorl %r14d, %r14d
leaq 0x6236(%rip), %r12      # 0x16aea
leaq 0x6099(%rip), %r15      # 0x16954
leaq 0xe37e(%rip), %rbx      # 0x1ec40
movq %rcx, -0x40(%rbp)
movq %rcx, %r13
movq %rcx, %rdi
movq %r12, %rsi
callq 0x2030
leaq (%rax,%r13), %rcx
movb (%r13,%rax), %dl
movzbl %dl, %eax
cmpl $0x2e, %eax
jle 0x10905
cmpl $0x5a, %eax
jle 0x1092c
cmpl $0x5b, %eax
je 0x1091b
cmpl $0x5d, %eax
jne 0x10962
testl %r14d, %r14d
jle 0x1096a
decl %r14d
cmpb $0x5b, (%r14,%rbx)
je 0x10962
jmp 0x1096a
cmpl $0x1f, %eax
jle 0x1094a
addl $-0x20, %eax
cmpl $0x9, %eax
ja 0x10962
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
cmpl $0x63, %r14d
jg 0x1096a
movslq %r14d, %rax
incl %r14d
movb %dl, (%rax,%rbx)
jmp 0x10962
cmpl $0x2f, %eax
jne 0x1095d
cmpb $0x2f, 0x1(%rcx)
jne 0x10962
jmp 0x1096a
testl %r14d, %r14d
jle 0x1096a
decl %r14d
cmpb $0x28, (%r14,%rbx)
je 0x10962
jmp 0x1096a
leal -0x9(%rax), %edx
cmpl $0x2, %edx
jb 0x1096a
testl %eax, %eax
je 0x1096a
cmpl $0xd, %eax
jne 0x10962
jmp 0x1096a
cmpl $0x3b, %eax
je 0x1096a
incq %rcx
jmp 0x108c6
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rbx
subq %rbx, %rcx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
testl %ecx, %ecx
je 0x109be
movslq %ecx, %r15
incq %r15
movq %r15, %rdi
callq 0x152b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2080
movq %rax, %r12
incq %r12
cmpq %r15, %r12
cmovaeq %r15, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2130
movb $0x0, -0x1(%r14,%r12)
jmp 0x109c1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/./command.h
// Function: parsefloat(char const*)
static inline float parsefloat(const char *s)
{
    // not all platforms (windows) can parse hexadecimal integers via strtod
    char *end;
    double val = strtod(s, &end);
    return val || end==s || (*end!='x' && *end!='X') ? float(val) : float(parseint(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x10(%rbp), %rsi
callq 0x2120
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10eaf
jnp 0x10eba
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq -0x10(%rbp), %rax
cmpq %rbx, %rax
je 0x10eaf
movzbl (%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x10eaf
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
jmp 0x10eb3