LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::input_adapter::input_adapter<char*, 0>(char*, char*)
input_adapter(IteratorType first, IteratorType last)
    {
#ifndef NDEBUG
        // assertion to check that the iterator range is indeed contiguous,
        // see http://stackoverflow.com/a/35008842/266378 for more discussion
        const auto is_contiguous = std::accumulate(
                                       first, last, std::pair<bool, int>(true, 0),
                                       [&first](std::pair<bool, int> res, decltype(*first) val)
        {
            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
            return res;
        }).first;
        assert(is_contiguous);
#endif

        // assertion to check that each element is 1 byte long
        static_assert(
            sizeof(typename iterator_traits<IteratorType>::value_type) == 1,
            "each element in the iterator range must have the size of 1 byte");

        const auto len = static_cast<size_t>(std::distance(first, last));
        if (JSON_HEDLEY_LIKELY(len > 0))
        {
            // there is at least one element: use the address of first
            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
        }
        else
        {
            // the address of first cannot be used: use nullptr
            ia = std::make_shared<input_buffer_adapter>(nullptr, len);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq %rdx, %rsi
je 0x496d
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %esi
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %r15, %rdx
movb (%rdx), %dil
movq %rsi, %r8
sarq $0x20, %r8
cmpb (%r15,%r8), %dil
sete %dil
andb %sil, %dil
andq %rax, %rsi
movzbl %dil, %r8d
orq %rsi, %r8
addq %rcx, %r8
incq %rdx
movq %r8, %rsi
cmpq %r14, %rdx
jne 0x48f1
testb %dil, %dil
je 0x49c8
subq %r15, %r14
je 0x496d
movl $0x28, %edi
callq 0x3210
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x141e5(%rip), %rcx     # 0x18b30
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x1424c(%rip), %rdx     # 0x18ba8
movq %rdx, 0x10(%rax)
movq %r15, 0x18(%rax)
addq %r15, %r14
movq %r14, 0x20(%rax)
jmp 0x49a8
movl $0x28, %edi
callq 0x3210
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x141a4(%rip), %rcx     # 0x18b30
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x1420b(%rip), %rdx     # 0x18ba8
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq %rcx, (%rbx)
movq 0x8(%rbx), %rdi
movq %rax, 0x8(%rbx)
testq %rdi, %rdi
je 0x49c2
popq %rbx
popq %r14
popq %r15
jmp 0x51e6
popq %rbx
popq %r14
popq %r15
retq
leaq 0xbd9b(%rip), %rdi      # 0x1076a
leaq 0xbda2(%rip), %rsi      # 0x10778
leaq 0xbdac(%rip), %rcx      # 0x10789
movl $0x10a5, %edx           # imm = 0x10A5
callq 0x3180
jmp 0x49e9
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x49fa
callq 0x51e6
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::key() const
const typename object_t::key_type& key() const
    {
        assert(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xef19
cmpb $0x1, (%rax)
jne 0xeebe
movq 0x8(%rdi), %rax
addq $0x20, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x41ae(%rip), %rsi      # 0x13089
leaq 0x41d0(%rip), %rdx      # 0x130b2
leaq 0x8(%rsp), %rdi
callq 0xe8e8
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0xa9ee
xorl %ebp, %ebp
leaq 0x9d0e(%rip), %rsi      # 0x18c18
leaq -0x758f(%rip), %rdx     # 0x7982
movq %rbx, %rdi
callq 0x33a0
leaq 0x4006(%rip), %rdi      # 0x12f26
leaq 0x1851(%rip), %rsi      # 0x10778
leaq 0x40ce(%rip), %rcx      # 0x12ffc
movl $0x26be, %edx           # imm = 0x26BE
callq 0x3180
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xef52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
testb %bpl, %bpl
jne 0xef5c
jmp 0xef64
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::series(unsigned int, unsigned int)
double Blowfish::series(uint32_t d, uint32_t j) {

    double sum = 0;
    for ( unsigned int k = 0; k < d; k++ ) {
        sum += (binaryExp(16, (d - k), (8 * k + j))) / (8 * k + j);
        sum = sum - (int)sum;
    }

    for ( unsigned int k = d; k < d + 100; k++ ) {
        sum += pow(16.0, (double) d - k) / (8 * k + j);
        sum = sum - (int)sum;
    }

    return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movl %esi, %ebx
xorpd %xmm1, %xmm1
testl %esi, %esi
je 0x2894
movl %ebx, %ebp
movl %r14d, %r15d
movapd %xmm1, 0x10(%rsp)
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x10, %esi
movl %ebp, %edx
callq 0x291c
movapd 0x10(%rsp), %xmm1
divsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
addl $0x8, %r15d
decl %ebp
jne 0x2848
cmpl $-0x65, %ebx
ja 0x290c
movl %ebx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
leal (%r14,%rbx,8), %ebp
xorl %r14d, %r14d
movapd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
leal (%rbx,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x735(%rip), %xmm0      # 0x3008
callq 0x20c0
movapd %xmm0, %xmm1
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
incl %r14d
addl $0x8, %ebp
movapd %xmm1, %xmm0
cmpl $0x64, %r14d
jne 0x28af
movapd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::binaryExp(int, int, double)
double Blowfish::binaryExp(int b, int n, double mod) {

    if (mod == 1.0) {
        return 0;
    }
    
    // Largest power of 2 less than n
    double t = pow(2, floor(log2(n)));

    double r = 1;
    while (t >= 1) {
        if (n >= t) {
            r = fmod(b * r, mod);
            n = n - t;
        }
        
        t = t / 2;

        if (t >= 1) {
            r = fmod(r * r, mod);
        }
    }

    return r;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x10(%rsp)
ucomisd 0x6d8(%rip), %xmm1      # 0x3010
jne 0x293c
jnp 0x2968
movl %edx, %ebx
movl %esi, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
callq 0x21b0
callq 0x2180
callq 0x20c0
movapd %xmm0, %xmm1
movsd 0x6ae(%rip), %xmm0      # 0x3010
ucomisd %xmm0, %xmm1
jae 0x296f
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x68c(%rip), %xmm0      # 0x3010
xorps %xmm2, %xmm2
cvtsi2sd %ebx, %xmm2
ucomisd %xmm1, %xmm2
jb 0x29c2
mulsd 0x18(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd %xmm2, 0x20(%rsp)
callq 0x2130
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebx
mulsd 0x656(%rip), %xmm1      # 0x3020
ucomisd 0x63e(%rip), %xmm1      # 0x3010
jb 0x2968
mulsd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
callq 0x2130
movsd 0x8(%rsp), %xmm1
jmp 0x2984
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/ethanmick[P]Blowfish482/Profile.cpp
// Function: print_uint8_hex(unsigned char*, unsigned int, char const*)
void print_uint8_hex(uint8_t* buffer, uint32_t size, const char* label) {
    printf("%s: ", label);
    for ( unsigned int i = 0; i < size; i++ ) {
        printf("%.2X ", buffer[ i ]);
        //cout << (uint32_t) buffer[ i ] << " ";
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x638(%rip), %rdi       # 0x3040
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x2a3a
movl %ebp, %r15d
leaq 0x625(%rip), %r14       # 0x3045
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
cmpq %r12, %r15
jne 0x2a23
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	vector<char> line;
	for(int i=1;i<argc;i++)
	{
		if(argv[i][0] == '-')
		{
			switch(argv[i][1])
			{
				case 'f':  //file
					execfile(argv[i]+2);
					break;

				case 'e': //evaluate
					execute(argv[i]+2);
					break;
					
				case 'h' : //help
					printf("Valid options: -f (executes file), -e (evaluates input) \n");
					break;

				default:
					conoutf("unkown option!");
					break;
			}
		}
	}

	return 0;
}

// Assembly:
cmpl $0x2, %edi
jl 0x3772
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r12d
movl $0x1, %r13d
leaq 0x13909(%rip), %r14     # 0x17013
leaq 0x138f3(%rip), %r15     # 0x17004
movq (%rbx,%r13,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x375c
movzbl 0x1(%rdi), %eax
cmpl $0x65, %eax
je 0x3747
cmpl $0x68, %eax
je 0x373d
cmpl $0x66, %eax
jne 0x3752
addq $0x2, %rdi
movl $0x1, %esi
callq 0x982f
jmp 0x375c
movq %r14, %rdi
callq 0x22d0
jmp 0x375c
addq $0x2, %rdi
callq 0x9578
jmp 0x375c
movq %r15, %rdi
xorl %eax, %eax
callq 0x35eb
incq %r13
cmpq %r13, %r12
jne 0x3711
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: clear_command()
void clear_command()
{
    enumerate(idents, ident, i, 
    {
        if(i.type==ID_ALIAS) 
        { 
            DELETEA(i.name);    
            i.forcenull();
            DELETEA(i.code);
        }
    });
}

// Assembly:
movl 0x1bde3(%rip), %eax     # 0x1f660
testl %eax, %eax
jle 0x3917
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq 0x1bdd0(%rip), %rcx     # 0x1f668
movq (%rcx,%rbx,8), %r14
testq %r14, %r14
je 0x3902
movq %r14, %r15
movq 0x40(%r14), %r14
cmpl $0x4, (%r15)
jne 0x38f7
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x38c4
callq 0x1572b
movq $0x0, 0x8(%r15)
cmpl $0x3, 0x10(%r15)
jne 0x38d9
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x38d9
callq 0x1572b
movl $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x38f7
callq 0x1572b
movq $0x0, 0x18(%r15)
testq %r14, %r14
jne 0x38a1
movl 0x1bd5e(%rip), %eax     # 0x1f660
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x3891
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: clearoverride(ident&)
void clearoverride(ident &i)
{
    if(!(i.flags&IDF_OVERRIDDEN)) return;
    switch(i.type)
    {
        case ID_ALIAS:
            if(i.valtype==VAL_STR) 
            {
                if(!i.val.s[0]) break;
                delete[] i.val.s;
            }
            cleancode(i);
            i.valtype = VAL_STR;
            i.val.s = newstring("");
            break;
        case ID_VAR:
            *i.storage.i = i.overrideval.i;
            i.changed();
            break;
        case ID_FVAR:
            *i.storage.f = i.overrideval.f;
            i.changed();
            break;
        case ID_SVAR:
            delete[] *i.storage.s;
            *i.storage.s = i.overrideval.s;
            i.changed();
            break;
    }
    i.flags &= ~IDF_OVERRIDDEN;
}

// Assembly:
testb $0x10, 0x38(%rdi)
je 0x39e8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x39de
leaq 0x1370e(%rip), %rcx     # 0x1704c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x28(%rbx), %eax
movq 0x20(%rbx), %rcx
movl %eax, (%rcx)
jmp 0x397d
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3967
callq 0x1572b
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
jmp 0x397d
movss 0x28(%rbx), %xmm0
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x39de
callq *%rax
jmp 0x39de
cmpl $0x3, 0x10(%rbx)
jne 0x399e
movq 0x20(%rbx), %rdi
cmpb $0x0, (%rdi)
je 0x39de
callq 0x1572b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x39c6
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x39be
callq 0x1572b
movq $0x0, 0x18(%rbx)
movl $0x3, 0x10(%rbx)
movl $0x1, %edi
callq 0x15705
movb $0x0, (%rax)
movq %rax, 0x20(%rbx)
andb $-0x11, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: addcommand(char const*, void (*)(), char const*)
bool addcommand(const char *name, identfun fun, const char *args)
{
    uint argmask = 0;
    int numargs = 0;
    bool limit = true;
    for(const char *fmt = args; *fmt; fmt++) switch(*fmt)
    {
        case 'i': case 'b': case 'f': case 't': case 'N': case 'D': if(numargs < MAXARGS) numargs++; break;
        case 's': case 'e': case 'r': case '$': if(numargs < MAXARGS) { argmask |= 1<<numargs; numargs++; } break;
        case '1': case '2': case '3': case '4': if(numargs < MAXARGS) fmt -= *fmt-'0'+1; break;
        case 'C': case 'V': limit = false; break;
        default: fatal("builtin %s declared with illegal type: %s", name, args); break;
    }
    if(limit && numargs > MAXCOMARGS) fatal("builtin %s declared with too many args: %d", name, numargs);
    addident(ident(ID_COMMAND, name, args, argmask, (void *)fun));
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movb $0x1, %r15b
leaq 0x13607(%rip), %r13     # 0x17060
xorl %ebx, %ebx
xorl %r12d, %r12d
movq %rdx, -0x38(%rbp)
movzbl (%r14), %eax
cmpl $0x55, %eax
jg 0x3a8b
cmpl $0x42, %eax
jg 0x3aa2
leal -0x31(%rax), %ecx
cmpl $0x4, %ecx
jae 0x3ace
cmpl $0x18, %r12d
jg 0x3b06
subq %rax, %r14
addq $0x2f, %r14
jmp 0x3b06
cmpl $0x71, %eax
jg 0x3ab3
leal -0x62(%rax), %ecx
cmpl $0x7, %ecx
ja 0x3ae2
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x43, %eax
je 0x3ae7
cmpl $0x44, %eax
je 0x3ac0
cmpl $0x4e, %eax
je 0x3ac0
jmp 0x3af0
leal -0x72(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3ad3
cmpl $0x74, %eax
jne 0x3af0
xorl %eax, %eax
cmpl $0x19, %r12d
setl %al
addl %eax, %r12d
jmp 0x3b06
cmpl $0x24, %eax
jne 0x3aec
cmpl $0x18, %r12d
jg 0x3b06
btsl %r12d, %ebx
incl %r12d
jmp 0x3b06
cmpl $0x56, %eax
jne 0x3af0
xorl %r15d, %r15d
jmp 0x3b06
testl %eax, %eax
je 0x3b0e
leaq 0x14358(%rip), %rdi     # 0x17e4f
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
xorl %eax, %eax
callq 0x35cd
incq %r14
jmp 0x3a62
cmpl $0xd, %r12d
setge %al
testb %al, %r15b
je 0x3b2f
leaq 0x14358(%rip), %rdi     # 0x17e79
movq -0x30(%rbp), %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x35cd
movl $0x3, -0x80(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movl %ebx, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x48(%rbp)
cmpb $0x0, 0x1c0d4(%rip)     # 0x1fc33
je 0x3b96
leaq -0x78(%rbp), %rsi
leaq 0x1baf4(%rip), %rdi     # 0x1f660
leaq -0x80(%rbp), %rdx
callq 0x12f18
leaq 0x1bb04(%rip), %rdi     # 0x1f680
movl 0x1bb0a(%rip), %ecx     # 0x1f68c
movl %ecx, 0x3c(%rax)
leaq -0x88(%rbp), %rsi
movq %rax, (%rsi)
callq 0x12fc6
jmp 0x3bc5
movq 0x1c09b(%rip), %rdi     # 0x1fc38
testq %rdi, %rdi
jne 0x3bbc
movl $0x10, %edi
callq 0x156f0
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x1c07c(%rip)     # 0x1fc38
leaq -0x80(%rbp), %rsi
callq 0x12eb0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: newident(char const*, int)
ident *newident(const char *name, int flags)
{
    ident *id = idents.access(name);
    if(!id)
    {
        if(checknumber(name)) 
        {
            debugcode("number %s is not a valid identifier name", name);
            return dummyident;
        }
        id = addident(ident(ID_ALIAS, newstring(name), flags));
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
leaq -0x28(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1b82f(%rip), %rdi     # 0x1f660
callq 0x12b3c
testq %rax, %rax
jne 0x3e63
movq -0x28(%rbp), %r14
movsbl (%r14), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x3e70
leaq 0x13ede(%rip), %rdi     # 0x17d30
movq %r14, %rsi
xorl %eax, %eax
callq 0x3f68
movq 0x1b82d(%rip), %rax     # 0x1f690
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %eax
cmpl $0x2b, %eax
je 0x3e82
cmpl $0x2e, %eax
je 0x3e9b
cmpl $0x2d, %eax
jne 0x3ead
movsbl 0x1(%r14), %ecx
leal -0x30(%rcx), %eax
cmpl $0xa, %eax
jb 0x3e4b
movl $0x2, %eax
cmpb $0x2e, %cl
je 0x3ea0
jmp 0x3ead
movl $0x1, %eax
movsbl (%r14,%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
jbe 0x3e4b
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x15705
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
movl $0x4, -0x68(%rbp)
movq %r12, -0x60(%rbp)
movl $0x0, -0x58(%rbp)
xorl %eax, %eax
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movl %ebx, -0x30(%rbp)
cmpb $0x0, 0x1bd3b(%rip)     # 0x1fc33
je 0x3f32
leaq -0x60(%rbp), %rsi
leaq 0x1b75b(%rip), %rdi     # 0x1f660
leaq -0x68(%rbp), %rdx
callq 0x12f18
leaq 0x1b76b(%rip), %rdi     # 0x1f680
movl 0x1b771(%rip), %ecx     # 0x1f68c
movl %ecx, 0x3c(%rax)
leaq -0x70(%rbp), %rsi
movq %rax, (%rsi)
callq 0x12fc6
movq (%rax), %rax
jmp 0x3e63
movq 0x1bcff(%rip), %rdi     # 0x1fc38
testq %rdi, %rdi
jne 0x3f58
movl $0x10, %edi
callq 0x156f0
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x1bce0(%rip)     # 0x1fc38
leaq -0x68(%rbp), %rsi
callq 0x12eb0
xorl %eax, %eax
jmp 0x3e63
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: debugcode(char const*, ...)
static void debugcode(const char *fmt, ...)
{
    if(nodebug) return;

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

    debugalias();
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x3e12
movq %rax, %rbx
movslq 0x3c(%rax), %rax
cmpq $0x18, %rax
jg 0x40ab
movq 0x1b1e2(%rip), %rcx     # 0x1f210
movl 0x10(%rcx), %edx
btl %eax, %edx
jb 0x40ab
movq 0x18(%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,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 0x1b647(%rip), %eax     # 0x1f6a8
movl %eax, 0x10(%rbx)
movq 0x1b635(%rip), %rax     # 0x1f6a0
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4097
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x408f
callq 0x1572b
movq $0x0, 0x18(%rbx)
movb 0x3c(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x1b168(%rip), %rcx     # 0x1f210
orl %eax, 0x10(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: resetvar(char*)
void resetvar(char *name)
{
    ident *id = idents.access(name);
    if(!id) return;
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else clearoverride(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1b556(%rip), %rdi     # 0x1f660
callq 0x12ba8
testq %rax, %rax
je 0x4136
testb $0x8, 0x38(%rax)
jne 0x4124
movq %rax, %rdi
callq 0x3918
jmp 0x4136
movq 0x8(%rax), %rsi
leaq 0x13c2a(%rip), %rdi     # 0x17d59
xorl %eax, %eax
callq 0x3f68
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setvar(char const*, int, bool, bool)
void setvar(const char *name, int i, bool dofunc, bool doclamp)
{
    GETVAR(id, name, );
    OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
    if(doclamp) *id->storage.i = clamp(i, id->minval, id->maxval);
    else *id->storage.i = i;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %r14d
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1b0f7(%rip), %rdi     # 0x1f660
callq 0x12b3c
testq %rax, %rax
je 0x4578
cmpl $0x0, (%rax)
je 0x4583
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x1b10f(%rip), %edx     # 0x1f698
andl $0x10, %edx
movl 0x38(%rax), %ecx
movl %ecx, %esi
andl $0x2, %esi
orl %edx, %esi
jne 0x45a2
testb $0x10, %cl
je 0x45bb
andl $-0x13, %ecx
jmp 0x45b8
testb $0x1, %cl
jne 0x45ed
testb $0x10, %cl
jne 0x45bb
movq 0x20(%rax), %rdx
movl (%rdx), %edx
movl %edx, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r15b, %r15b
je 0x45d5
movl 0x10(%rax), %ecx
movl 0x18(%rax), %edx
cmpl %edx, %r14d
cmovll %r14d, %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movl %edx, %r14d
movq 0x20(%rax), %rcx
movl %r14d, (%rcx)
testb %bl, %bl
je 0x4578
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x4578
callq *%rax
jmp 0x4578
movq 0x8(%rax), %rsi
leaq 0x13783(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
callq 0x3f68
jmp 0x4578
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvar(char const*, float, bool, bool)
void setfvar(const char *name, float f, bool dofunc, bool doclamp)
{
    _GETVAR(id, ID_FVAR, name, );
    OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
    if(doclamp) *id->storage.f = clamp(f, id->minvalf, id->maxvalf);
    else *id->storage.f = f;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %ebx
movss %xmm0, -0x14(%rbp)
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1b039(%rip), %rdi     # 0x1f660
callq 0x12b3c
testq %rax, %rax
je 0x46c4
cmpl $0x1, (%rax)
jne 0x46c4
movl 0x1b054(%rip), %edx     # 0x1f698
andl $0x10, %edx
movl 0x38(%rax), %ecx
movl %ecx, %esi
andl $0x2, %esi
orl %edx, %esi
jne 0x465d
testb $0x10, %cl
je 0x467a
andl $-0x13, %ecx
jmp 0x4677
testb $0x1, %cl
jne 0x46b2
testb $0x10, %cl
jne 0x467a
movq 0x20(%rax), %rdx
movss (%rdx), %xmm0
movss %xmm0, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r14b, %r14b
je 0x4694
movss 0x10(%rax), %xmm0
movss -0x14(%rbp), %xmm1
minss 0x18(%rax), %xmm1
maxss %xmm1, %xmm0
jmp 0x4699
movss -0x14(%rbp), %xmm0
movq 0x20(%rax), %rcx
movss %xmm0, (%rcx)
testb %bl, %bl
je 0x46c4
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x46c4
callq *%rax
jmp 0x46c4
movq 0x8(%rax), %rsi
leaq 0x136be(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
callq 0x3f68
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvar(char const*, char const*, bool)
void setsvar(const char *name, const char *str, bool dofunc)
{
    _GETVAR(id, ID_SVAR, name, );
    OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
    *id->storage.s = newstring(str);
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
leaq -0x30(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1af72(%rip), %rdi     # 0x1f660
callq 0x12b3c
testq %rax, %rax
je 0x47b7
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x47b7
movl 0x1af8a(%rip), %ecx     # 0x1f698
andl $0x10, %ecx
movl 0x38(%r14), %eax
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
jne 0x474e
testb $0x10, %al
je 0x473b
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x4734
callq 0x1572b
movl 0x38(%r14), %eax
andl $-0x11, %eax
movl %eax, 0x38(%r14)
movq 0x20(%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4768
callq 0x1572b
jmp 0x4768
testb $0x1, %al
jne 0x47a5
movq 0x20(%r14), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x4742
movq %rdi, 0x28(%r14)
orl $0x10, %eax
movl %eax, 0x38(%r14)
movq %r15, %rdi
callq 0x2080
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x15705
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2130
movq 0x20(%r14), %rax
movq %r13, (%rax)
testb %bl, %bl
je 0x47b7
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x47b7
callq *%rax
jmp 0x47b7
movq 0x8(%r14), %rsi
leaq 0x135cb(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
callq 0x3f68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: icmd_getalias<600>::run(char*)
int clampvar(ident *id, int val, int minval, int maxval)
{
    if(val < minval) val = minval;
    else if(val > maxval) val = maxval;
    else return val;
    debugcode(id->flags&IDF_HEX ?
            (minval <= 255 ? "valid range for %s is %d..0x%X" : "valid range for %s is 0x%X..0x%X") :
            "valid range for %s is %d..%d",
        id->name, minval, maxval);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x4a7f
movq %rax, %rbx
movq 0x1a69e(%rip), %r12     # 0x1f208
movq %rax, %rdi
callq 0x2080
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x15705
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movl $0x3, 0x8(%r12)
movq %r15, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setvarchecked(ident*, int)
void setvarchecked(ident *id, int val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
        if(val < id->minval || val > id->maxval) val = clampvar(id, val, id->minval, id->maxval);
        *id->storage.i = val;
        id->changed();                                             // call trigger function if available
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4c7c
movl 0x1aa3e(%rip), %ecx     # 0x1f698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4c89
testb $0x1, %al
jne 0x4cce
testb $0x10, %al
jne 0x4c93
movq 0x20(%rbx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rbx)
orl $0x10, %eax
jmp 0x4c90
movq 0x8(%rbx), %rsi
leaq 0x130d2(%rip), %rdi     # 0x17d59
jmp 0x4cd9
testb $0x10, %al
je 0x4c93
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movl 0x10(%rbx), %edx
movl 0x18(%rbx), %ecx
cmpl %esi, %edx
setg %al
cmpl %esi, %ecx
setl %dil
orb %al, %dil
cmpb $0x1, %dil
jne 0x4cb7
movq %rbx, %rdi
callq 0x4bf2
movl %eax, %esi
movq 0x20(%rbx), %rax
movl %esi, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x4ce6
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x130a2(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f68
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvarchecked(ident*, float)
void setfvarchecked(ident *id, float val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
        if(val < id->minvalf || val > id->maxvalf) val = clampfvar(id, val, id->minvalf, id->maxvalf);
        *id->storage.f = val;
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4dfe
movl 0x1a8c0(%rip), %ecx     # 0x1f698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4e0b
testb $0x1, %al
jne 0x4e4a
testb $0x10, %al
jne 0x4e15
movq 0x20(%rbx), %rcx
movss (%rcx), %xmm1
movss %xmm1, 0x28(%rbx)
orl $0x10, %eax
jmp 0x4e12
movq 0x8(%rbx), %rsi
leaq 0x12f50(%rip), %rdi     # 0x17d59
jmp 0x4e55
testb $0x10, %al
je 0x4e15
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movss 0x10(%rbx), %xmm1
movss 0x18(%rbx), %xmm2
ucomiss %xmm0, %xmm1
ja 0x4e29
ucomiss %xmm2, %xmm0
jbe 0x4e31
movq %rbx, %rdi
callq 0x4ce9
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x4e62
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x12f26(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f68
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvarchecked(ident*, char const*)
void setsvarchecked(ident *id, const char *val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
        *id->storage.s = newstring(val);
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4eae
movq %rsi, %r14
movl 0x1a815(%rip), %ecx     # 0x1f698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4ebb
testb $0x1, %al
jne 0x4f26
movq 0x20(%rbx), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x4edd
movq %rdi, 0x28(%rbx)
orl $0x10, %eax
movl %eax, 0x38(%rbx)
jmp 0x4ee7
movq 0x8(%rbx), %rsi
leaq 0x12ea0(%rip), %rdi     # 0x17d59
jmp 0x4f31
testb $0x10, %al
je 0x4ed6
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4ed0
callq 0x1572b
movl 0x38(%rbx), %eax
andl $-0x11, %eax
movl %eax, 0x38(%rbx)
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4ee7
callq 0x1572b
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x15705
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
movq 0x20(%rbx), %rax
movq %r12, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x4f40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x12e4a(%rip), %rdi     # 0x17d7b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f68
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: unescapestring(char*, char const*, char const*)
int unescapestring(char *dst, const char *src, const char *end)
{
    char *start = dst;
    while(src < end)
    {
        int c = *src++;
        if(c == '^')
        {
            if(src >= end) break;
            int e = *src++;
            switch(e)
            {
                case 'n': *dst++ = '\n'; break;
                case 't': *dst++ = '\t'; break;
                case 'f': *dst++ = '\f'; break;
                default: *dst++ = e; break;
            }
        }
        else *dst++ = c;
    }
    return dst - start;
}

// Assembly:
movq %rdi, %rax
cmpq %rdx, %rsi
jae 0x4fd4
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x1(%rsi), %r8
movb (%rsi), %cl
cmpb $0x5e, %cl
jne 0x4fbc
cmpq %rdx, %r8
jae 0x4fd3
movzbl 0x1(%rsi), %ecx
addq $0x2, %rsi
cmpl $0x66, %ecx
je 0x4fcf
cmpl $0x6e, %ecx
je 0x4fcb
cmpl $0x74, %ecx
jne 0x4fbf
movb $0x9, %cl
jmp 0x4fbf
movq %r8, %rsi
movb %cl, (%rax)
incq %rax
cmpq %rdx, %rsi
jb 0x4f91
jmp 0x4fd3
movb $0xa, %cl
jmp 0x4fbf
movb $0xc, %cl
jmp 0x4fbf
popq %rbp
subl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: compilecode(char const*)
uint *compilecode(const char *p)
{
    vector<uint> buf;
    buf.reserve(64);
    compilemain(buf, p);
    uint *code = new uint[buf.length()];
    memcpy(code, buf.getbuf(), buf.length()*sizeof(uint));
    code[0] += 0x100;
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movl $0x40, %esi
callq 0x131ba
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x508c
movslq -0x24(%rbp), %rax
leaq (,%rax,4), %r14
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x15705
movq %rax, %rbx
movq -0x30(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2130
addl $0x100, (%rbx)          # imm = 0x100
movl $0x0, -0x24(%rbp)
testq %r15, %r15
je 0x505a
movq %r15, %rdi
callq 0x1572b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x506c
jmp 0x506c
movq %rax, %rbx
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x5084
callq 0x1572b
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Fohlen[P]cubescript-standalone/command.cpp
// Function: keepcode(unsigned int*)
void keepcode(uint *code)
{
    if(!code) return;
    switch(*code&CODE_OP_MASK)
    {
        case CODE_START:
            *code += 0x100;
            return;
    }
    switch(code[-1]&CODE_OP_MASK)
    {
        case CODE_START:
            code[-1] += 0x100;
            break;
        case CODE_OFFSET:
            code -= int(code[-1]>>8);
            *code += 0x100;
            break;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x512f
movl (%rdi), %eax
testb $0x3f, %al
je 0x5123
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
je 0x511f
cmpl $0x1, %ecx
jne 0x512f
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl (%rdi), %eax
jmp 0x5123
addq $-0x4, %rdi
pushq %rbp
movq %rsp, %rbp
addl $0x100, %eax            # imm = 0x100
movl %eax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5162
movl (%rdi), %eax
testb $0x3f, %al
je 0x5164
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1, %ecx
je 0x5178
testl %ecx, %ecx
jne 0x5162
addq $-0x4, %rdi
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jl 0x5172
popq %rbp
retq
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, (%rdi)
cmpl $0x100, %eax            # imm = 0x100
jge 0x5162
popq %rbp
jmp 0x1572b
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
addl (%rdi), %eax
movl %eax, (%rdi)
cmpl $0xff, %eax
jg 0x5162
jmp 0x5172
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51ac
testb $0x4, 0x38(%rdi)
jne 0x51b9
leaq 0x12cfa(%rip), %rax     # 0x17ea4
jmp 0x51f7
movq 0x8(%rdi), %rsi
leaq 0x12ced(%rip), %rdi     # 0x17ea4
jmp 0x51fe
cmpl $0xffffff, 0x18(%rdi)   # imm = 0xFFFFFF
jne 0x51f0
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 0x12cc4(%rip), %rdi     # 0x17eac
xorl %eax, %eax
popq %rbp
jmp 0x35eb
leaq 0x12cce(%rip), %rax     # 0x17ec5
movq 0x8(%rdi), %rsi
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x35eb
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52bc
cmpl $0x1, %eax
je 0x529c
testl %eax, %eax
jne 0x52f7
movq 0x20(%rbx), %rax
movl (%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5193
movq 0x8(%rbx), %r14
movq 0x20(%rbx), %rax
movss (%rax), %xmm0
callq 0x4d4c
leaq 0x12c1b(%rip), %rdi     # 0x17ecf
movq %r14, %rsi
movq %rax, %rdx
jmp 0x52ec
movq 0x20(%rbx), %rax
movq (%rax), %r14
movq %r14, %rdi
movl $0x22, %esi
callq 0x2060
testq %rax, %rax
leaq 0x12c07(%rip), %rax     # 0x17ee1
leaq 0x12bf6(%rip), %rdi     # 0x17ed7
cmoveq %rax, %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x35eb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
movl $0x40, %esi
callq 0x131ba
leaq -0x20(%rbp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x508c
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x52fc
movq -0x20(%rbp), %rdi
cmpl $0xff, (%rdi)
jg 0x91d3
movl $0x0, -0x14(%rbp)
callq 0x1572b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x91de
movq %rax, %rbx
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x91f6
callq 0x1572b
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq -0x28(%rbp), %rbx
movq %rbx, %rsi
callq 0x52fc
movl 0x8(%rbx), %eax
leaq 0xf04e(%rip), %rbx      # 0x1826f
cmpq $0x6, %rax
ja 0x929f
leaq 0xe522(%rip), %rcx      # 0x17750
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %eax, %eax
jmp 0x92f0
movl -0x28(%rbp), %edx
movl 0x1654d(%rip), %eax     # 0x1f794
incl %eax
andl $0x3, %eax
movl %eax, 0x16542(%rip)     # 0x1f794
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq 0x1653f(%rip), %r14     # 0x1f7a0
addq %r14, %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xec2f(%rip), %rsi      # 0x17ea1
xorl %eax, %eax
callq 0x12e1e
movl 0x16515(%rip), %eax     # 0x1f794
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %rbx
addq %r14, %rbx
jmp 0x929c
movss -0x28(%rbp), %xmm0
callq 0x4d4c
movq %rax, %rbx
movl -0x20(%rbp), %eax
movq -0x28(%rbp), %rdi
cmpl $0x5, %eax
je 0x92b4
cmpl $0x3, %eax
jne 0x92c3
testq %rdi, %rdi
jne 0x92be
jmp 0x92c3
cmpl $0x0, -0x4(%rdi)
jne 0x92c3
addq $-0x4, %rdi
callq 0x1572b
movq %rbx, %rdi
callq 0x2080
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x15705
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movq %r15, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xef58(%rip), %r14      # 0x1826f
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
ja 0x9396
leaq 0xe446(%rip), %rdx      # 0x1776c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rbx), %r14
jmp 0x93e8
movss (%rbx), %xmm0
callq 0x4d4c
movq %rax, %r14
jmp 0x9393
movl (%rbx), %edx
movl 0x16447(%rip), %eax     # 0x1f794
incl %eax
andl $0x3, %eax
movl %eax, 0x1643c(%rip)     # 0x1f794
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq 0x16439(%rip), %r15     # 0x1f7a0
addq %r15, %rax
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xeb29(%rip), %rsi      # 0x17ea1
xorl %eax, %eax
callq 0x12e1e
movl 0x1640f(%rip), %eax     # 0x1f794
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
movl 0x8(%rbx), %eax
movq (%rbx), %rdi
cmpl $0x5, %eax
je 0x93aa
cmpl $0x3, %eax
jne 0x93b9
testq %rdi, %rdi
jne 0x93b4
jmp 0x93b9
cmpl $0x0, -0x4(%rdi)
jne 0x93b9
addq $-0x4, %rdi
callq 0x1572b
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x15705
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_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq -0x28(%rbp), %rbx
movq %rbx, %rsi
callq 0x9175
movl 0x8(%rbx), %eax
leaq 0xee54(%rip), %rbx      # 0x1826f
cmpq $0x6, %rax
ja 0x9499
leaq 0xe35c(%rip), %rcx      # 0x17784
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %eax, %eax
jmp 0x94ea
movl -0x28(%rbp), %edx
movl 0x16353(%rip), %eax     # 0x1f794
incl %eax
andl $0x3, %eax
movl %eax, 0x16348(%rip)     # 0x1f794
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq 0x16345(%rip), %r14     # 0x1f7a0
addq %r14, %rax
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xea35(%rip), %rsi      # 0x17ea1
xorl %eax, %eax
callq 0x12e1e
movl 0x1631b(%rip), %eax     # 0x1f794
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,4), %rbx
addq %r14, %rbx
jmp 0x9496
movss -0x28(%rbp), %xmm0
callq 0x4d4c
movq %rax, %rbx
movl -0x20(%rbp), %eax
movq -0x28(%rbp), %rdi
cmpl $0x5, %eax
je 0x94ae
cmpl $0x3, %eax
jne 0x94bd
testq %rdi, %rdi
jne 0x94b8
jmp 0x94bd
cmpl $0x0, -0x4(%rdi)
jne 0x94bd
addq $-0x4, %rdi
callq 0x1572b
movq %rbx, %rdi
callq 0x2080
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x15705
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movq %r15, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52fc
xorl %ebx, %ebx
movl 0x8(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
ja 0x953d
leaq 0xe27f(%rip), %rdx      # 0x177a0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
movq %rax, %rbx
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rdi
cmpl $0x5, %eax
je 0x955e
cmpl $0x3, %eax
jne 0x956d
testq %rdi, %rdi
jne 0x9568
jmp 0x956d
cvttss2si -0x20(%rbp), %ebx
jmp 0x956d
movl -0x20(%rbp), %ebx
jmp 0x956d
cmpl $0x0, -0x4(%rdi)
jne 0x956d
addq $-0x4, %rdi
callq 0x1572b
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
movl $0x40, %esi
callq 0x131ba
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x508c
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
leaq -0x30(%rbp), %rsi
callq 0x52fc
movq -0x20(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jl 0x95cd
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
xorl %ebx, %ebx
movl -0x28(%rbp), %eax
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
ja 0x95fd
leaq 0xe1d7(%rip), %rdx      # 0x177b8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2050
movq %rax, %rbx
movl -0x28(%rbp), %eax
movq -0x30(%rbp), %rdi
cmpl $0x5, %eax
je 0x961e
cmpl $0x3, %eax
jne 0x962d
testq %rdi, %rdi
jne 0x9628
jmp 0x962d
cvttss2si -0x30(%rbp), %ebx
jmp 0x962d
movl -0x30(%rbp), %ebx
jmp 0x962d
cmpl $0x0, -0x4(%rdi)
jne 0x962d
addq $-0x4, %rdi
callq 0x1572b
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x9642
callq 0x1572b
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x964f
jmp 0x964f
movq %rax, %rbx
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x9667
callq 0x1572b
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52fc
movq %r14, %rdi
callq 0x96c2
movl %eax, %ebx
movq (%r14), %rdi
movl 0x8(%r14), %eax
cmpl $0x5, %eax
je 0x96a8
cmpl $0x3, %eax
jne 0x96b7
testq %rdi, %rdi
jne 0x96b2
jmp 0x96b7
cmpl $0x0, -0x4(%rdi)
jne 0x96b7
addq $-0x4, %rdi
callq 0x1572b
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq