LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
leaq -0x48(%rbp), %r12
leaq -0x60(%rbp), %r13
leaq -0x58(%rbp), %r15
leaq -0x50(%rbp), %r14
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x7b77
testb %al, %al
je 0x88cb
movq -0x48(%rbp), %rsi
movl -0x60(%rbp), %edx
subl %esi, %edx
movq %rbx, %rdi
callq 0x877d
testl %eax, %eax
jns 0x8872
cmpl $0x0, -0x34(%rbp)
je 0x88b7
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
jmp 0x8872
leaq -0x48(%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 $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x890f
jmp 0x890f
jmp 0x890f
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: listsplice(char const*, char const*, int*, int*, int*)
void listsplice(const char *s, const char *vals, int *skip, int *count, int *numargs)
{
    int offset = max(*skip, 0), len = *numargs >= 4 ? max(*count, 0) : -1;
    const char *list = s, *start, *end, *qstart, *qend = s;
    loopi(offset) if(!parselist(s, start, end, qstart, qend)) break;
    vector<char> p;
    if(qend > list) p.put(list, qend-list);
    if(*vals)
    {
        if(!p.empty()) p.add(' ');
        p.put(vals, strlen(vals));
    }
    while(len-- > 0) if(!parselist(s)) break;
    skiplist(s);
    switch(*s)
    {
        case '\0': case ')': case ']': break;
        default:
            if(!p.empty()) p.add(' ');
            p.put(s, strlen(s));
            break;
    }
    p.add('\0');
    commandret->setstr(newstring(p.getbuf(), p.length()-1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x48(%rbp)
movl (%rdx), %eax
cmpl $0x4, (%r8)
movq %rsi, -0x60(%rbp)
jl 0x8975
movl (%rcx), %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
jmp 0x8979
pushq $-0x1
popq %r15
leaq -0x50(%rbp), %rcx
movq %rdi, -0x58(%rbp)
movq %rdi, (%rcx)
xorl %r12d, %r12d
testl %eax, %eax
cmovgl %eax, %r12d
incl %r12d
leaq -0x78(%rbp), %r13
leaq -0x70(%rbp), %rbx
leaq -0x68(%rbp), %r14
decl %r12d
je 0x89bb
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
leaq -0x50(%rbp), %r8
callq 0x7b77
testb %al, %al
jne 0x899c
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rsi
cmpq %rsi, %rdx
movq -0x60(%rbp), %rbx
jbe 0x89de
subl %esi, %edx
leaq -0x40(%rbp), %rdi
callq 0xd2d6
cmpb $0x0, (%rbx)
je 0x8a0f
cmpl $0x0, -0x34(%rbp)
je 0x89f9
leaq -0x29(%rbp), %rsi
movb $0x20, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq %rbx, %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xd2d6
incl %r15d
leaq 0x111cf(%rip), %r14     # 0x19be8
leaq 0x111b0(%rip), %rbx     # 0x19bd0
leaq 0x111b1(%rip), %r12     # 0x19bd8
leaq -0x48(%rbp), %r13
decl %r15d
testl %r15d, %r15d
jle 0x8a4f
movq %r13, %rdi
leaq 0x111a3(%rip), %rsi     # 0x19be0
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x7b77
testb %al, %al
jne 0x8a2b
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x8146
movq (%rbx), %rbx
movzbl (%rbx), %eax
testl %eax, %eax
je 0x8a9b
cmpl $0x29, %eax
je 0x8a9b
cmpl $0x5d, %eax
je 0x8a9b
cmpl $0x0, -0x34(%rbp)
je 0x8a85
leaq -0x29(%rbp), %rsi
movb $0x20, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq %rbx, %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xd2d6
leaq -0x29(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0xd296
movq 0x1076e(%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 0x8aea
jmp 0x8aea
jmp 0x8aea
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: 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, -0x50(%rbp)
movq %rdi, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rsi, -0x58(%rbp)
movq %rsi, %rdi
callq 0x20a0
testl %eax, %eax
je 0x9e5f
cltq
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %r15
movq %r13, %rdi
movq -0x58(%rbp), %rsi
callq 0x2040
movq %rax, %r12
testq %rax, %rax
je 0x9e08
cmpq %r12, %r13
jae 0x9e31
leaq 0x1(%r13), %r14
movq %r15, %rdi
movq %r13, %rsi
callq 0xd296
movq %r14, %r13
jmp 0x9ddd
leaq 0x1(%r13), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0xd296
movq %rbx, %r13
cmpb $0x0, (%r13)
jne 0x9df6
movb $0x0, -0x29(%rbp)
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xd339
movq %rax, %rbx
jmp 0x9e54
movq -0x50(%rbp), %r13
cmpb $0x0, (%r13)
je 0x9e4c
movq %r15, %rdi
movq %r13, %rsi
callq 0xd296
incq %r13
jmp 0x9e35
movq -0x48(%rbp), %rax
leaq (%r12,%rax), %r13
testq %r12, %r12
jne 0x9dc9
jmp 0x9e6a
movq %r13, %rdi
callq 0xd0ec
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e8f
jmp 0x9e8f
jmp 0x9e8f
jmp 0x9e8f
jmp 0x9e8f
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: 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, 0xf7d2(%rip)      # 0x196d0
je 0x9f9d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0xf30d(%rip), %rax      # 0x19228
leaq 0xf30e(%rip), %r15      # 0x19230
movq (%rax), %rax
cmpq %r15, %rax
je 0x9f32
incl %ebx
addq $0x8, %rax
jmp 0x9f22
leaq 0xf2ef(%rip), %r12      # 0x19228
pushq $0x1
popq %r13
leaq 0x7ce0(%rip), %r14      # 0x11c24
movq (%r12), %r12
cmpq %r15, %r12
je 0x9f8f
movq (%r12), %rax
movl 0xf779(%rip), %ecx      # 0x196d0
movq %r14, %rsi
cmpl %ecx, %r13d
jl 0x9f74
cmpq %r15, 0x8(%r12)
jne 0x9f84
cmpl %ecx, %r13d
leaq 0x7cbd(%rip), %rsi      # 0x11c2d
cmoveq %r14, %rsi
movq 0x8(%rax), %rcx
pushq $0x4
popq %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x358a
addq $0x8, %r12
decl %ebx
incl %r13d
jmp 0x9f44
addq $0x8, %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: 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 0xf276(%rip), %rax      # 0x19228
movl 0x10(%rax), %edx
movslq 0x3c(%rdi), %rcx
btl %ecx, %edx
jae 0x9fec
cmpl $0x3, 0x10(%rbx)
jne 0x9fd2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9fd2
callq 0xf9a8
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x389a
imulq $0x18, %rcx, %rdx
addq 0x18(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b34
movb 0x3c(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movq 0xf21a(%rip), %rcx      # 0x19228
orl %eax, 0x10(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setalias(ident&, tagval&)
static inline void setalias(ident &id, tagval &v)
{
    if(id.valtype == VAL_STR) delete[] id.val.s;
    id.setval(v);
    cleancode(id);
    id.flags = (id.flags & identflags) | identflags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, 0x10(%rdi)
jne 0xa037
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xa037
callq 0xf9a8
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x389a
movl 0xf655(%rip), %eax      # 0x196a8
movl %eax, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./command.h
// Function: getstr(identval const&, int)
static inline const char *getstr(const identval &v, int type) 
{
    switch(type)
    {
        case VAL_STR: case VAL_MACRO: return v.s;
        case VAL_INT: return intstr(v.i);
        case VAL_FLOAT: return floatstr(v.f);
        default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7ca9(%rip), %rax      # 0x11d0f
decl %esi
cmpl $0x5, %esi
ja 0xa080
leaq 0x74c0(%rip), %rcx      # 0x11534
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq (%rdi), %rax
popq %rbp
retq
movss (%rdi), %xmm0
popq %rbp
jmp 0x4653
movl (%rdi), %edi
popq %rbp
jmp 0x748f
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: skipcomments(char const*&)
static inline void skipcomments(const char *&p)
{
    for(;;)
    {
        p += strspn(p, " \t\r");
        if(p[0]!='/' || p[1]!='/') break;
        p += strcspn(p, "\n\0");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x726f(%rip), %r14      # 0x11c95
leaq 0x6d00(%rip), %r15      # 0x1172d
movq %r12, %rdi
movq %r14, %rsi
callq 0x2090
leaq (%r12,%rax), %r13
movq %r13, (%rbx)
cmpb $0x2f, (%r12,%rax)
jne 0xaa63
cmpb $0x2f, 0x1(%r13)
jne 0xaa63
movq %r13, %rdi
movq %r15, %rsi
callq 0x2030
movq %rax, %r12
addq %r13, %r12
movq %r12, (%rbx)
jmp 0xaa2d
addq $0x8, %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: compilestr(vector<unsigned int>&, char const*, int, bool)
static inline void compilestr(vector<uint> &code, const char *word, int len, bool macro = false)
{
    if(len <= 3 && !macro)
    {
        uint op = CODE_VALI|RET_STR;
        for(int i = 0; i < len; i++) op |= uint(uchar(word[i]))<<((i+1)*8);
        code.add(op);
        return;
    }
    code.add((macro ? CODE_MACRO : CODE_VAL|RET_STR)|(len<<8));
    code.put((const uint *)word, len/sizeof(uint));
    size_t endlen = len%sizeof(uint);
    union
    {
        char c[sizeof(uint)];
        uint u;
    } end;
    end.u = 0;
    memcpy(end.c, word + len - endlen, endlen);
    code.add(end.u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x4, %edx
setge %al
orb %cl, %al
je 0xb13a
testb %cl, %cl
pushq $0x7
popq %rax
movl $0xc5, %ecx
cmovnel %eax, %ecx
movl %r14d, %eax
shll $0x8, %eax
orl %ecx, %eax
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
movslq %r14d, %r12
movl %r14d, %edx
sarl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd87a
leaq -0x2c(%rbp), %r13
andl $0x0, (%r13)
andl $0x3, %r14d
addq %r15, %r12
subq %r14, %r12
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2150
movq %rbx, %rdi
movq %r13, %rsi
jmp 0xb16a
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movl $0xc6, %edx
pushq $0x8
popq %rcx
cmpq %rax, %r14
je 0xb161
movzbl (%r15,%rax), %esi
shll %cl, %esi
incq %rax
orl %esi, %edx
addl $0x8, %ecx
jmp 0xb14b
leaq -0x34(%rbp), %rsi
movl %edx, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
addq $0x18, %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: compilearg(vector<unsigned int>&, char const*&, int)
static inline bool compilearg(vector<uint> &code, const char *&p, int wordtype)
{
    char *word = NULL;
    int wordlen = 0;
    bool more = compileword(code, p, wordtype, word, wordlen);
    if(!more) return false;
    if(word) 
    {
        compileval(code, wordtype, word, wordlen);
        delete[] word;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %rcx
andq $0x0, (%rcx)
leaq -0x24(%rbp), %r8
andl $0x0, (%r8)
callq 0xaa72
movl %eax, %r15d
testb %al, %al
je 0xb1cf
movq -0x30(%rbp), %r12
testq %r12, %r12
je 0xb1cf
movl -0x24(%rbp), %ecx
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0xb88a
movq %r12, %rdi
callq 0xf9a8
movl %r15d, %eax
addq $0x10, %rsp
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: 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 0xd7c0
movl %r14d, %eax
shll $0x8, %eax
addl $0x201, %eax            # imm = 0x201
leaq -0x18(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
leaq -0x14(%rbp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
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_O2/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 0xb37d
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, 0xe338(%rip)      # 0x196d8
jne 0xb47e
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 0xe31f(%rip), %r13      # 0x196f0
testq %r13, %r13
je 0xb46a
movq %rdi, %r15
pushq $0x1
popq %r14
pushq $0xa
popq %r12
movq %r13, %rdi
movl %r12d, %esi
callq 0x2070
testq %rax, %rax
jne 0xb400
movq %r13, %rdi
callq 0x20a0
addq %r13, %rax
cmpq %r15, %r13
seta %cl
cmpq %r15, %rax
setb %dl
orb %cl, %dl
je 0xb420
cmpb $0x0, (%rax)
je 0xb46a
incq %rax
incl %r14d
movq %rax, %r13
jmp 0xb3e5
movq 0xe2c1(%rip), %rdx      # 0x196e8
leaq 0xe892(%rip), %r15      # 0x19cc0
leaq -0x30(%rbp), %rdi
testq %rdx, %rdx
je 0xb450
movq %r15, (%rdi)
leaq 0x6870(%rip), %rsi      # 0x11cb1
movl %r14d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xd450
jmp 0xb467
movq %r15, (%rdi)
leaq 0x685a(%rip), %rsi      # 0x11cb4
movl %r14d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xd450
movq %r15, %rbx
pushq $0x4
popq %rdi
leaq -0x50(%rbp), %rdx
movq %rbx, %rsi
callq 0x34ff
callq 0x9ef7
addq $0xd8, %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: cutstring(char const*&, int&)
static inline char *cutstring(const char *&p, int &len)
{
    p++;
    const char *end = parsestring(p);
    char *s = newstring(end - p);         
    len = unescapestring(s, p, end);
    s[len] = '\0';
    p = end;
    if(*p=='\"') p++;
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r15
incq %r15
movq %r15, (%rdi)
movq %r15, %rdi
callq 0x47ed
movq %rax, %r14
movq %rax, %rdi
subq %r15, %rdi
callq 0xd31f
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4826
movl %eax, (%r12)
cltq
movb $0x0, (%r15,%rax)
movq %r14, (%rbx)
cmpb $0x22, (%r14)
jne 0xb4eb
incq %r14
movq %r14, (%rbx)
movq %r15, %rax
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: 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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xbb83
movq %rax, (%r15)
subq %rbx, %rax
movl %eax, (%r14)
testl %eax, %eax
je 0xb87d
movslq %eax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd339
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: compileval(vector<unsigned int>&, int, char*, int)
static inline void compileval(vector<uint> &code, int wordtype, char *word, int wordlen)
{
    switch(wordtype)
    {
        case VAL_STR: compilestr(code, word, wordlen, true); break;
        case VAL_ANY: compilestr(code, word, wordlen); break;
        case VAL_FLOAT: compilefloat(code, word); break;
        case VAL_INT: compileint(code, word); break;
        case VAL_CODE: 
        {
            int start = code.length();
            code.add(CODE_BLOCK);
            code.add(CODE_OFFSET|((start+2)<<8));
            const char *p = word;
            compilestatements(code, p, VAL_ANY);
            code.add(CODE_EXIT|RET_STR);
            code[start] |= uint(code.length() - (start + 1))<<8;
            break;
        }
        case VAL_IDENT: compileident(code, word); break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
decl %esi
cmpl $0x6, %esi
ja 0xb991
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x5d3b(%rip), %rax      # 0x115ec
movslq (%rax,%rsi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
testq %r14, %r14
je 0xb99e
movq %r14, %rdi
callq 0xbc51
movl %eax, %esi
jmp 0xb9a0
pushq $0x1
popq %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
movl %eax, %ecx
jmp 0xb918
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb2d7
testq %r14, %r14
je 0xb9b4
movq %r14, %rdi
callq 0xbcd7
jmp 0xb9b7
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb0b6
movslq 0xc(%rbx), %r12
leaq -0x28(%rbp), %r15
movl $0x9, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7c0
movl %r12d, %eax
shll $0x8, %eax
addl $0x201, %eax            # imm = 0x201
movl %eax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7c0
movq %r14, (%r15)
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa094
leaq -0x2c(%rbp), %rsi
movl $0xc4, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
movl %r12d, %eax
notl %eax
addl 0xc(%rbx), %eax
shll $0x8, %eax
movq (%rbx), %rcx
orl %eax, (%rcx,%r12,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb1fc
xorps %xmm0, %xmm0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xbc5f
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: parseword(char const*)
static inline const char *parseword(const char *p)
{
    const int maxbrak = 100;
    static char brakstack[maxbrak];
    int brakdepth = 0;
    for(;; p++)
    {
        p += strcspn(p, "\"/;()[] \t\r\n\0");
        switch(p[0])
        {
            case '"': case ';': case ' ': case '\t': case '\r': case '\n': case '\0': return p;
            case '/': if(p[1] == '/') return p; break;
            case '[': case '(': if(brakdepth >= maxbrak) return p; brakstack[brakdepth++] = p[0]; break;
            case ']': if(brakdepth <= 0 || brakstack[--brakdepth] != '[') return p; break;
            case ')': if(brakdepth <= 0 || brakstack[--brakdepth] != '(') return p; break;
        }
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
xorl %r15d, %r15d
leaq 0x5ba0(%rip), %rbx      # 0x1173e
leaq 0xe0ab(%rip), %r12      # 0x19c50
leaq 0x5a5c(%rip), %r13      # 0x11608
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2030
movq %rax, %rcx
addq %r14, %rax
movb (%r14,%rcx), %dl
movzbl %dl, %ecx
leal -0x20(%rcx), %esi
cmpl $0x9, %esi
jbe 0xbbf6
cmpl $0x2f, %ecx
je 0xbc34
cmpl $0x5b, %ecx
je 0xbc00
cmpl $0x5d, %ecx
je 0xbc23
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xbc42
testl %ecx, %ecx
je 0xbc42
cmpl $0xd, %ecx
je 0xbc42
cmpl $0x3b, %ecx
jne 0xbc3a
jmp 0xbc42
movslq (%r13,%rsi,4), %rcx
addq %r13, %rcx
jmpq *%rcx
cmpl $0x63, %r15d
jg 0xbc42
movslq %r15d, %rcx
incl %r15d
movb %dl, (%rcx,%r12)
jmp 0xbc3a
testl %r15d, %r15d
jle 0xbc42
decl %r15d
cmpb $0x28, (%r15,%r12)
je 0xbc3a
jmp 0xbc42
testl %r15d, %r15d
jle 0xbc42
decl %r15d
cmpb $0x5b, (%r15,%r12)
je 0xbc3a
jmp 0xbc42
cmpb $0x2f, 0x1(%rax)
je 0xbc42
incq %rax
jmp 0xbbac
addq $0x8, %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: compilefloat(vector<unsigned int>&, float)
static inline void compilefloat(vector<uint> &code, float f)
{
    if(int(f) == f && f >= -0x800000 && f <= 0x7FFFFF)
        code.add(CODE_VALI|RET_FLOAT|(int(f)<<8));
    else
    {
        union { float f; uint u; } conv;
        conv.f = f;
        code.add(CODE_VAL|RET_FLOAT);
        code.add(conv.u);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x5ae3(%rip), %xmm1     # 0x11758
ucomiss %xmm0, %xmm1
jb 0xbca8
ucomiss 0x5adb(%rip), %xmm0     # 0x1175c
jb 0xbca8
cvttps2dq %xmm0, %xmm1
cvtdq2ps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jne 0xbca8
jp 0xbca8
cvttss2si %xmm0, %eax
shll $0x8, %eax
orl $0x86, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
jmp 0xbcc9
leaq -0x18(%rbp), %r14
movss %xmm0, (%r14)
leaq -0x14(%rbp), %rsi
movl $0x85, (%rsi)
movq %rbx, %rdi
callq 0xd7c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: forcearg(tagval&, int)
static inline void forcearg(tagval &v, int type)
{
    switch(type)
    {
        case RET_STR: if(v.type != VAL_STR) forcestr(v); break;
        case RET_INT: if(v.type != VAL_INT) forceint(v); break;
        case RET_FLOAT: if(v.type != VAL_FLOAT) forcefloat(v); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x40, %esi
je 0xbd53
cmpl $0x80, %esi
je 0xbd47
cmpl $0xc0, %esi
jne 0xbd59
cmpl $0x3, 0x8(%rdi)
je 0xbd59
popq %rbp
jmp 0x6e6b
cmpl $0x2, 0x8(%rdi)
je 0xbd59
popq %rbp
jmp 0xbdfe
cmpl $0x1, 0x8(%rdi)
jne 0xbd5b
popq %rbp
retq
popq %rbp
jmp 0xbda6
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: forceint(tagval&)
static inline int forceint(tagval &v)
{
    int i = 0;
    switch(v.type)
    {
        case VAL_FLOAT: i = v.f; break;
        case VAL_STR: i = parseint(v.s); break;
        case VAL_MACRO: i = parseint(v.s); break;
        case VAL_INT: return v.i;
    }
    freearg(v);
    v.setint(i);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
xorl %r14d, %r14d
decl %eax
cmpl $0x5, %eax
ja 0xbde4
leaq 0x586c(%rip), %rcx      # 0x11630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0xbc51
movl %eax, %r14d
jmp 0xbde4
movl (%rbx), %r14d
jmp 0xbdf6
cvttss2si (%rbx), %r14d
movq %rbx, %rdi
callq 0x3745
movl $0x1, 0x8(%rbx)
movl %r14d, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: forcefloat(tagval&)
static inline float forcefloat(tagval &v)
{
    float f = 0.0f;
    switch(v.type)
    {
        case VAL_INT: f = v.i; break;
        case VAL_STR: f = parsefloat(v.s); break;
        case VAL_MACRO: f = parsefloat(v.s); break;
        case VAL_FLOAT: return v.f;
    }
    freearg(v);
    v.setfloat(f);
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
xorps %xmm0, %xmm0
decl %eax
cmpl $0x5, %eax
ja 0xbe32
leaq 0x582d(%rip), %rcx      # 0x11648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0xbcd7
jmp 0xbe32
cvtsi2ssl (%rbx), %xmm0
movss %xmm0, -0xc(%rbp)
movq %rbx, %rdi
callq 0x3745
movss -0xc(%rbp), %xmm0
movl $0x2, 0x8(%rbx)
movss %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movss (%rbx), %xmm0
jmp 0xbe4f
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: conc(vector<char>&, tagval*, int, bool, char const*, int)
static char *conc(vector<char> &buf, tagval *v, int n, bool space, const char *prefix = NULL, int prefixlen = 0)
{
    if(prefix)
    {
        buf.put(prefix, prefixlen);
        if(space && n) buf.add(' ');
    }
    loopi(n)
    {
        const char *s = "";
        int len = 0;
        switch(v[i].type)
        {
            case VAL_INT: s = intstr(v[i].i); break;
            case VAL_FLOAT: s = floatstr(v[i].f); break;
            case VAL_STR: s = v[i].s; break;
            case VAL_MACRO: s = v[i].s; len = v[i].code[-1]>>8; goto haslen;
        }
        len = int(strlen(s));
    haslen:
        buf.put(s, len);
        if(i == n-1) break;
        if(space) buf.add(' ');
    }
    buf.add('\0');
    return buf.getbuf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leal -0x1(%r14), %eax
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %r14d
shlq $0x4, %r14
shlq $0x4, %rax
movq %rax, -0x38(%rbp)
cmpq %r12, %r14
je 0xc8bc
movl 0x8(%r15,%r12), %eax
decl %eax
leaq 0x54d0(%rip), %r13      # 0x11d0f
cmpl $0x5, %eax
ja 0xc87a
leaq 0x4e69(%rip), %rcx      # 0x116b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x54b6(%rip), %r13      # 0x11d0f
jmpq *%rax
movl (%r15,%r12), %edi
callq 0x748f
jmp 0xc877
movq (%r15,%r12), %r13
jmp 0xc87a
movss (%r15,%r12), %xmm0
callq 0x4653
movq %rax, %r13
movq %r13, %rdi
callq 0x20a0
movq %rax, %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd2d6
cmpq %r12, -0x38(%rbp)
je 0xc8bc
movb $0x20, -0x29(%rbp)
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0xd296
addq $0x10, %r12
jmp 0xc828
movq (%r15,%r12), %r13
movl -0x4(%r13), %edx
shrl $0x8, %edx
jmp 0xc885
leaq -0x2a(%rbp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0xd296
movq (%rbx), %rax
addq $0x18, %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: forceident(tagval&)
static inline ident *forceident(tagval &v)
{
    switch(v.type)
    {
        case VAL_IDENT: return v.id;
        case VAL_MACRO:
        {
            ident *id = newident(v.s, IDF_UNKNOWN);
            v.setident(id);
            return id;
        }
        case VAL_STR: 
        { 
            ident *id = newident(v.s, IDF_UNKNOWN); 
            delete[] v.s; 
            v.setident(id); 
            return id; 
        }
    }
    freearg(v);
    v.setident(dummyident);
    return dummyident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0xc918
cmpl $0x6, %eax
je 0xc8fe
cmpl $0x7, %eax
jne 0xc935
movq (%rbx), %r14
jmp 0xc94e
movq (%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x3be8
movq %rax, %r14
movl $0x7, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0xc94e
movq (%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x3be8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc944
callq 0xf9a8
jmp 0xc944
movq %rbx, %rdi
callq 0x3745
movq 0xcd5c(%rip), %r14      # 0x196a0
movl $0x7, 0x8(%rbx)
movq %r14, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./command.h
// Function: getint(identval const&, int)
static inline int getint(const identval &v, int type)
{
    switch(type)
    {
        case VAL_INT: return v.i;
        case VAL_FLOAT: return int(v.f);
        case VAL_STR: case VAL_MACRO: return parseint(v.s); 
        default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
decl %esi
cmpl $0x5, %esi
ja 0xc984
leaq 0x4d62(%rip), %rcx      # 0x116cc
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq (%rdi), %rdi
popq %rbp
jmp 0xbc51
cvttss2si (%rdi), %eax
jmp 0xc984
movl (%rdi), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./command.h
// Function: getfloat(identval const&, int)
static inline float getfloat(const identval &v, int type)
{
    switch(type)
    {
        case VAL_FLOAT: return v.f;
        case VAL_INT: return float(v.i);
        case VAL_STR: case VAL_MACRO: return parsefloat(v.s);
        default: return 0.0f;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
decl %esi
cmpl $0x5, %esi
ja 0xc9b7
leaq 0x4d49(%rip), %rax      # 0x116e4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rdi), %rdi
popq %rbp
jmp 0xbcd7
movss (%rdi), %xmm0
jmp 0xc9b7
cvtsi2ssl (%rdi), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./tools.h
// Function: hashset<ident>::hashset(int)
hashset(int size = 1<<10)
      : size(size)
    {
        numelems = 0;
        chunks = NULL;
        unused = NULL;
        chains = new chain *[size];
        loopi(size) chains[i] = NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
andl $0x0, 0x4(%rdi)
movl %esi, %eax
shlq $0x3, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %r15d, %r15d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r15d, %ebx
callq 0xf989
movq %rax, 0x8(%r14)
cmpq %r15, %rbx
je 0xd076
movq 0x8(%r14), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0xd063
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./tools.h
// Function: copystring(char*, char const*, unsigned long)
inline char *copystring(char *d, const char *s, size_t len = MAXSTRLEN)
{
    size_t slen = min(strlen(s)+1, len);
    memcpy(d, s, slen);
    d[slen-1] = 0;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x20a0
movq %rax, %r12
incq %r12
cmpq %rbx, %r12
cmovaeq %rbx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2150
movb $0x0, -0x1(%r15,%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./tools.h
// Function: vector<ident>::growbuf(int)
void growbuf(int sz)
    {
        int olen = alen;
        if(!alen) alen = max(MINSIZE, sz);
        else while(alen < sz) alen *= 2;
        if(alen <= olen) return;
        uchar *newbuf = new uchar[alen*sizeof(T)];
        if(olen > 0)
        {
            memcpy(newbuf, (void *)buf, olen*sizeof(T));
            delete[] (uchar *)buf;
        }
        buf = (T *)newbuf;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
testq %r14, %r14
je 0xd681
movl %r14d, %eax
cmpl %esi, %eax
jge 0xd68d
addl %eax, %eax
movl %eax, 0x8(%rbx)
jmp 0xd676
cmpl $0x9, %esi
pushq $0x8
popq %rax
cmovgel %esi, %eax
movl %eax, 0x8(%rbx)
cmpl %r14d, %eax
jle 0xd6cb
movslq %eax, %rdi
shlq $0x6, %rdi
callq 0xf989
movq %rax, %r15
testl %r14d, %r14d
jle 0xd6c8
movq (%rbx), %r12
shlq $0x6, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2150
testq %r12, %r12
je 0xd6c8
movq %r12, %rdi
callq 0xf9a8
movq %r15, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./tools.h
// Function: hashset<ident>::insert(unsigned int)
chain *insert(uint h)
    {
        if(!unused)
        {
            chainchunk *chunk = new chainchunk;
            chunk->next = chunks;
            chunks = chunk;
            loopi(CHUNKSIZE-1) chunk->chains[i].next = &chunk->chains[i+1];
            chunk->chains[CHUNKSIZE-1].next = unused;
            unused = chunk->chains;
        }
        chain *c = unused;
        unused = unused->next;
        c->next = chains[h];
        chains[h] = c;
        numelems++;
        return c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0xd725
movl $0x1208, %edi           # imm = 0x1208
callq 0xf974
movq 0x10(%rbx), %rcx
movq %rcx, 0x1200(%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rcx
addq $0x48, %rcx
pushq $0x3f
popq %rdx
subq $0x1, %rdx
jb 0xd71d
movq %rcx, -0x8(%rcx)
addq $0x48, %rcx
jmp 0xd70d
andq $0x0, 0x11f8(%rax)
movq 0x40(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq 0x8(%rbx), %rcx
movl %r14d, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, 0x40(%rax)
movq %rax, (%rcx,%rdx,8)
incl 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/./command.h
// Function: ident::getval(tagval&) const
inline void ident::getval(tagval &v) const
{
    switch(valtype)
    {
        case VAL_STR: case VAL_MACRO: v.setstr(newstring(val.s)); break;
        case VAL_INT: v.setint(val.i); break;
        case VAL_FLOAT: v.setfloat(val.f); break;
        default: v.setnull(); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0xd992
leaq 0x3e3c(%rip), %rcx      # 0x11790
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rdi), %rdi
callq 0xd0ec
movl $0x3, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0xd999
movss 0x20(%rdi), %xmm0
movl $0x2, 0x8(%rbx)
movss %xmm0, (%rbx)
jmp 0xd999
movl 0x20(%rdi), %eax
movl $0x1, 0x8(%rbx)
movl %eax, (%rbx)
jmp 0xd999
andl $0x0, 0x8(%rbx)
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: sortfun::operator()(sortitem const&, sortitem const&)
bool operator()(const sortitem &xval, const sortitem &yval)
    {
        if(x->valtype != VAL_MACRO) x->valtype = VAL_MACRO;
        cleancode(*x);
        x->val.code = (const uint *)xval.str;
        if(y->valtype != VAL_MACRO) y->valtype = VAL_MACRO;
        cleancode(*y);
        y->val.code = (const uint *)yval.str;
        return executebool(body);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x6, 0x10(%rdi)
je 0xdc00
movl $0x6, 0x10(%rdi)
movq (%rbx), %rdi
callq 0x389a
movq (%r15), %rax
movq (%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%rbx), %rdi
cmpl $0x6, 0x10(%rdi)
je 0xdc24
movl $0x6, 0x10(%rdi)
movq 0x8(%rbx), %rdi
callq 0x389a
movq (%r14), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6fd4
nop
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/stream.cpp
// Function: makerelpath(char const*, char const*, char const*, char const*)
char *makerelpath(const char *dir, const char *file, const char *prefix, const char *cmd)
{
    static string tmp;
    if(prefix) copystring(tmp, prefix);
    else tmp[0] = '\0';
    if(file[0]=='<')
    {
        const char *end = strrchr(file, '>');
        if(end)
        {
            size_t len = strlen(tmp);
            copystring(&tmp[len], file, min(sizeof(tmp)-len, size_t(end+2-file)));
            file = end+1;
        }
    }
    if(cmd) concatstring(tmp, cmd);
    if(dir)
    {
        defformatstring(pname)("%s/%s", dir, file);
        concatstring(tmp, pname);
    }
    else concatstring(tmp, file);
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xe07d
movq %rdx, %rax
leaq 0xc202(%rip), %rdi      # 0x1a270
movl $0x104, %edx            # imm = 0x104
movq %rax, %rsi
callq 0xd24d
jmp 0xe084
movb $0x0, 0xc1ec(%rip)      # 0x1a270
cmpb $0x3c, (%rbx)
jne 0xe0d8
pushq $0x3e
popq %rsi
movq %rbx, %rdi
callq 0x21e0
testq %rax, %rax
je 0xe0d8
movq %rax, %r12
leaq 0xc1cd(%rip), %r13      # 0x1a270
movq %r13, %rdi
callq 0x20a0
addq %rax, %r13
movl $0x104, %ecx            # imm = 0x104
subq %rax, %rcx
movq %r12, %rdx
subq %rbx, %rdx
addq $0x2, %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd24d
incq %r12
movq %r12, %rbx
testq %r15, %r15
je 0xe0f1
leaq 0xc18c(%rip), %rdi      # 0x1a270
movl $0x104, %edx            # imm = 0x104
movq %r15, %rsi
callq 0xef32
testq %r14, %r14
je 0xe129
leaq -0x140(%rbp), %r15
leaq -0x30(%rbp), %rdi
movq %r15, (%rdi)
leaq 0x469d(%rip), %rsi      # 0x127a8
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xd450
leaq 0xc151(%rip), %rdi      # 0x1a270
movl $0x104, %edx            # imm = 0x104
movq %r15, %rsi
jmp 0xe138
leaq 0xc140(%rip), %rdi      # 0x1a270
movl $0x104, %edx            # imm = 0x104
movq %rbx, %rsi
callq 0xef32
leaq 0xc12c(%rip), %rax      # 0x1a270
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/stream.cpp
// Function: path(char*)
char *path(char *s)
{
    for(char *curpart = s;;)
    {
        char *endpart = strchr(curpart, '&');
        if(endpart) *endpart = '\0';
        if(curpart[0]=='<')
        {
            char *file = strrchr(curpart, '>');
            if(!file) return s;
            curpart = file+1;
        }
        for(char *t = curpart; (t = strpbrk(t, "/\\")); *t++ = PATHDIV);
        for(char *prevdir = NULL, *curdir = curpart;;)
        {
            prevdir = curdir[0]==PATHDIV ? curdir+1 : curdir;
            curdir = strchr(prevdir, PATHDIV);
            if(!curdir) break;
            if(prevdir+1==curdir && prevdir[0]=='.')
            {
                memmove(prevdir, curdir+1, strlen(curdir+1)+1);
                curdir = prevdir;
            }
            else if(curdir[1]=='.' && curdir[2]=='.' && curdir[3]==PATHDIV)
            {
                if(prevdir+2==curdir && prevdir[0]=='.' && prevdir[1]=='.') continue;
                memmove(prevdir, curdir+4, strlen(curdir+4)+1);
                curdir = prevdir;
            }
        }
        if(endpart)
        {
            *endpart = '&';
            curpart = endpart+1;
        }
        else break;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x4640(%rip), %r12      # 0x127ae
pushq $0x2f
popq %r13
movq %rdi, -0x30(%rbp)
movq %r15, %rdi
pushq $0x26
popq %rsi
callq 0x2070
movq %rax, %r14
testq %rax, %rax
je 0xe18d
movb $0x0, (%r14)
cmpb $0x3c, (%r15)
jne 0xe1ad
movq %r15, %rdi
pushq $0x3e
popq %rsi
callq 0x21e0
testq %rax, %rax
je 0xe254
movq %rax, %r15
incq %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x23a0
testq %rax, %rax
je 0xe224
movq %rax, %rdi
incq %rdi
movb $0x2f, (%rax)
jmp 0xe1b0
movq %rax, %r15
leaq 0x1(%rbx), %rax
cmpq %r15, %rax
jne 0xe1dc
cmpb $0x2e, (%rbx)
pushq $0x1
popq %rcx
je 0xe207
cmpb $0x2e, 0x1(%r15)
jne 0xe224
cmpb $0x2e, 0x2(%r15)
jne 0xe224
cmpb $0x2f, 0x3(%r15)
jne 0xe224
leaq 0x2(%rbx), %rdx
pushq $0x4
popq %rcx
cmpq %r15, %rdx
jne 0xe207
cmpb $0x2e, (%rbx)
jne 0xe207
cmpb $0x2e, (%rax)
je 0xe224
addq %rcx, %r15
movq %r15, %rdi
callq 0x20a0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2360
movq %rbx, %r15
xorl %ebx, %ebx
cmpb $0x2f, (%r15)
sete %bl
addq %r15, %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2070
testq %rax, %rax
jne 0xe1c8
testq %r14, %r14
je 0xe254
movb $0x26, (%r14)
incq %r14
movq %r14, %r15
jmp 0xe176
movq -0x30(%rbp), %rax
addq $0x8, %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/stream.cpp
// Function: parentdir(char const*)
const char *parentdir(const char *directory)
{
    const char *p = directory + strlen(directory);
    while(p > directory && *p != '/' && *p != '\\') p--;
    static string parent;
    size_t len = p-directory+1;
    copystring(parent, directory, len);
    return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20a0
leaq (%rbx,%rax), %rcx
cmpq %rbx, %rcx
jbe 0xe2bc
movzbl (%rcx), %ecx
cmpl $0x2f, %ecx
je 0xe2bc
cmpl $0x5c, %ecx
je 0xe2bc
decq %rax
jmp 0xe2a1
incq %rax
leaq 0xc1ca(%rip), %r14      # 0x1a490
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd24d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/stream.cpp
// Function: createdir(char const*)
bool createdir(const char *path)
{
    size_t len = strlen(path);
    if(path[len-1]==PATHDIV)
    {
        static string strip;
        path = copystring(strip, path, len);
    }
#ifdef WIN32
    return CreateDirectory(path, NULL)!=0;
#else
    return mkdir(path, 0777)==0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20a0
cmpb $0x2f, -0x1(%rbx,%rax)
jne 0xe366
leaq 0xc248(%rip), %rdi      # 0x1a5a0
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd24d
movq %rax, %rbx
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20b0
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/stream.cpp
// Function: fixpackagedir(char*)
size_t fixpackagedir(char *dir)
{
    path(dir);
    size_t len = strlen(dir);
    if(len > 0 && dir[len-1] != PATHDIV)
    {
        dir[len] = PATHDIV;
        dir[len+1] = '\0';
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe156
movq %rbx, %rdi
callq 0x20a0
testq %rax, %rax
je 0xe3a7
cmpb $0x2f, -0x1(%rbx,%rax)
je 0xe3a7
movw $0x2f, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/stream.cpp
// Function: subhomedir(char*, int, char const*)
bool subhomedir(char *dst, int len, const char *src)
{
    const char *sub = strstr(src, "$HOME");
    if(!sub) sub = strchr(src, '~');
    if(sub && sub-src < len)
    {
#ifdef WIN32
        char home[MAX_PATH+1];
        home[0] = '\0';
        if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, home) != S_OK || !home[0]) return false;
#else
        const char *home = getenv("HOME");
        if(!home || !home[0]) return false;
#endif
        dst[sub-src] = '\0';
        concatstring(dst, home);
        concatstring(dst, sub+(*sub == '~' ? 1 : strlen("$HOME")));
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x43e7(%rip), %rsi      # 0x127b3
movq %rdx, %rdi
callq 0x2040
testq %rax, %rax
jne 0xe3e9
pushq $0x7e
popq %rsi
movq %r12, %rdi
callq 0x2070
testq %rax, %rax
je 0xe44c
movq %rax, %r15
movq %rax, %r13
subq %r12, %r13
movslq %r14d, %rax
movb $0x1, %r14b
cmpq %rax, %r13
jge 0xe44f
leaq 0x43b0(%rip), %rdi      # 0x127b4
callq 0x2250
testq %rax, %rax
je 0xe447
cmpb $0x0, (%rax)
je 0xe447
movb $0x0, (%rbx,%r13)
movl $0x104, %edx            # imm = 0x104
movq %rbx, %rdi
movq %rax, %rsi
callq 0xef32
xorl %eax, %eax
cmpb $0x7e, (%r15)
setne %al
leaq (%r15,%rax,4), %rsi
incq %rsi
movl $0x104, %edx            # imm = 0x104
movq %rbx, %rdi
callq 0xef32
jmp 0xe44f
xorl %r14d, %r14d
jmp 0xe44f
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %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/stream.cpp
// Function: sethomedir(char const*)
const char *sethomedir(const char *dir)
{
    string pdir;
    copystring(pdir, dir);
    if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return NULL;
    copystring(homedir, pdir);
    return homedir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq -0x120(%rbp), %r14
movl $0x104, %edx            # imm = 0x104
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd24d
movq %r14, %rdi
movl $0x104, %esi            # imm = 0x104
movq %rbx, %rdx
callq 0xe3ae
testb %al, %al
je 0xe4cb
leaq -0x120(%rbp), %rdi
callq 0xe37f
testq %rax, %rax
je 0xe4cb
leaq 0xbc9b(%rip), %rbx      # 0x1a150
leaq -0x120(%rbp), %rsi
movl $0x104, %edx            # imm = 0x104
movq %rbx, %rdi
callq 0xd24d
jmp 0xe4cd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq