LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::Prepend(char const*)
void String::Prepend(const char *cstr)
{
    if (cstr)
    {
        size_t length = strlen(cstr);
        if (length > 0)
        {
            ReserveAndShift(true, length);
            memcpy(_meta->CStr - length, cstr, length);
            _meta->Length += length;
            _meta->CStr -= length;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2a292
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x2a290
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x281c0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
subq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4300
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
addq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rsi
movq (%rax), %rax
movq 0x18(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
jmp 0x2a292
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::PrependChar(char)
void String::PrependChar(char c)
{
    if (c)
    {
        ReserveAndShift(true, 1);
        _meta->Length++;
        _meta->CStr--;
        _meta->CStr[0] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x2a301
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x281c0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movq (%rax), %rcx
movq 0x18(%rcx), %rdx
addq $-0x1, %rdx
movq %rdx, 0x18(%rcx)
movb -0x9(%rbp), %cl
movq (%rax), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::Replace(char, char)
void String::Replace(char what, char with)
{
    if (_meta && what && with && what != with)
    {
        BecomeUnique();
        char *rep_ptr = _meta->CStr;
        while (*rep_ptr)
        {
            if (*rep_ptr == what)
            {
                *rep_ptr = with;
            }
            rep_ptr++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x2a396
cmpb $0x0, -0x9(%rbp)
je 0x2a396
cmpb $0x0, -0xa(%rbp)
je 0x2a396
movsbl -0x9(%rbp), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
je 0x2a396
movq -0x20(%rbp), %rdi
callq 0x29d40
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2a394
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2a386
movb -0xa(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2a365
jmp 0x2a396
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::ReplaceMid(unsigned long, unsigned long, char const*)
void String::ReplaceMid(size_t from, size_t count, const char *cstr)
{
    if (!cstr)
        cstr = "";
    size_t length = strlen(cstr);
    Math::ClampLength(from, count, (size_t)0, GetLength());
    ReserveAndShift(false, Math::Surplus(length, count));
    memmove(_meta->CStr + from + length, _meta->CStr + from + count, GetLength() - (from + count) + 1);
    memcpy(_meta->CStr + from, cstr, length);
    _meta->Length += length - count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2a3d2
leaq 0x9d9e(%rip), %rax      # 0x3416c
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41d0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x2ab50
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x2ac10
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ade0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x281c0
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2ab50
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
subq %rax, %rdx
addq $0x1, %rdx
callq 0x4600
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
addq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4300
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq -0x18(%rbp), %rcx
movq (%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TrimLeft(char)
void String::TrimLeft(char c)
{
    if (!_meta || !_meta->Length)
    {
        return;
    }

    const char *trim_ptr = _meta->CStr;
    for (;;)
    {
        auto t = *trim_ptr;
        if (t == 0) { break; }
        if (c && t != c) { break; }
        if (!c && !isspace(t)) { break; }
        trim_ptr++;
    }
    size_t trimmed = trim_ptr - _meta->CStr;
    if (trimmed > 0)
    {
        BecomeUnique();
        _meta->Length -= trimmed;
        _meta->CStr += trimmed;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x2a58e
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2a593
jmp 0x2a639
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x2a5b6
jmp 0x2a5ee
cmpb $0x0, -0x9(%rbp)
je 0x2a5ca
movsbl -0x19(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x2a5ca
jmp 0x2a5ee
cmpb $0x0, -0x9(%rbp)
jne 0x2a5e0
movsbl -0x19(%rbp), %edi
callq 0x40a0
cmpl $0x0, %eax
jne 0x2a5e0
jmp 0x2a5ee
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2a5a2
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x2a639
movq -0x30(%rbp), %rdi
callq 0x29d40
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rsi
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
subq %rsi, %rdx
movq %rdx, 0x10(%rcx)
movq -0x28(%rbp), %rcx
movq (%rax), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TrimRight(char)
void String::TrimRight(char c)
{
    if (!_meta || !_meta->Length)
    {
        return;
    }

    const char *trim_ptr = _meta->CStr + _meta->Length - 1;
    for (;;) 
    {
        if (trim_ptr < _meta->CStr) { break; }
        auto t = *trim_ptr;
        if (c && t != c) { break; }
        if (!c && !isspace(t)) { break; }
        trim_ptr--;
    }
    size_t trimmed = (_meta->CStr + _meta->Length - 1) - trim_ptr;
    if (trimmed > 0)
    {
        BecomeUnique();
        _meta->Length -= trimmed;
        _meta->CStr[_meta->Length] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x2a66e
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2a673
jmp 0x2a73a
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
addq 0x10(%rcx), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2a6a0
jmp 0x2a6e1
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x2a6bd
movsbl -0x19(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x2a6bd
jmp 0x2a6e1
cmpb $0x0, -0x9(%rbp)
jne 0x2a6d3
movsbl -0x19(%rbp), %edi
callq 0x40a0
cmpl $0x0, %eax
jne 0x2a6d3
jmp 0x2a6e1
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2a68d
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
addq 0x10(%rcx), %rax
addq $-0x1, %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x2a73a
movq -0x30(%rbp), %rdi
callq 0x29d40
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq (%rcx), %rax
movq 0x10(%rax), %rdx
subq %rsi, %rdx
movq %rdx, 0x10(%rax)
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToLeft(unsigned long)
void String::TruncateToLeft(size_t count)
{
    if (_meta)
    {
        count = Math::Min(count, _meta->Length);
        if (count < _meta->Length)
        {
            BecomeUnique();
            _meta->Length = count;
            _meta->CStr[_meta->Length] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x2a7b6
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x10, %rsi
leaq -0x10(%rbp), %rdi
callq 0x2ab90
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2a7b4
movq -0x18(%rbp), %rdi
callq 0x29d40
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx), %rax
movq %rdx, 0x10(%rax)
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2a7b6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToMid(unsigned long, unsigned long)
void String::TruncateToMid(size_t from, size_t count)
{
    if (_meta)
    {
        Math::ClampLength(from, count, (size_t)0, _meta->Length);
        if (from > 0 || count < _meta->Length)
        {
            BecomeUnique();
            _meta->Length = count;
            _meta->CStr += from;
            _meta->CStr[_meta->Length] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x2a859
movq -0x28(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq (%rax), %rcx
addq $0x10, %rcx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2ac10
cmpq $0x0, -0x10(%rbp)
ja 0x2a81e
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2a857
movq -0x28(%rbp), %rdi
callq 0x29d40
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx), %rax
movq %rdx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq (%rcx), %rax
addq 0x18(%rax), %rdx
movq %rdx, 0x18(%rax)
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2a859
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToRight(unsigned long)
void String::TruncateToRight(size_t count)
{
    if (_meta)
    {
        count = Math::Min(count, GetLength());
        if (count < _meta->Length)
        {
            BecomeUnique();
            _meta->CStr += _meta->Length - count;
            _meta->Length = count;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x2a8e0
movq -0x20(%rbp), %rdi
callq 0x2ab50
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ab90
movq -0x20(%rbp), %rcx
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2a8de
movq -0x20(%rbp), %rdi
callq 0x29d40
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
subq -0x10(%rbp), %rdx
movq (%rax), %rcx
addq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x2a8e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToLeftSection(char, bool)
void String::TruncateToLeftSection(char separator, bool exclude_separator)
{
    if (_meta && separator)
    {
        size_t slice_at = FindChar(separator);
        if (slice_at != -1)
        {
            TruncateToLeft(exclude_separator ? slice_at : slice_at + 1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x2a964
cmpb $0x0, -0x9(%rbp)
je 0x2a964
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x9(%rbp), %esi
callq 0x289f0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x2a962
testb $0x1, -0xa(%rbp)
je 0x2a949
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2a955
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2a740
jmp 0x2a964
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToRightSection(char, bool)
void String::TruncateToRightSection(char separator, bool exclude_separator)
{
    if (_meta && separator)
    {
        size_t slice_at = FindCharReverse(separator);
        if (slice_at != -1)
        {
            TruncateToRight(exclude_separator ? _meta->Length - slice_at - 1 : _meta->Length - slice_at);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x2a9fd
cmpb $0x0, -0x9(%rbp)
je 0x2a9fd
movq -0x20(%rbp), %rdi
movq $-0x1, %rdx
movsbl -0x9(%rbp), %esi
callq 0x28a90
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x2a9fb
testb $0x1, -0xa(%rbp)
je 0x2a9db
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
subq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2a9ee
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2a860
jmp 0x2a9fd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToSection(char, unsigned long, unsigned long, bool, bool)
void String::TruncateToSection(char separator, size_t first, size_t last,
                          bool exclude_first_sep, bool exclude_last_sep)
{
    if (!_meta || !separator)
    {
        return;
    }

    size_t slice_from;
    size_t slice_to;
    if (FindSection(separator, first, last, exclude_first_sep, exclude_last_sep,
        slice_from, slice_to))
    {
        TruncateToMid(slice_from, slice_to - slice_from);
    }
    else
    {
        Empty();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x5c(%rbp)
movq %rcx, %rax
movl -0x5c(%rbp), %ecx
movq %rax, -0x58(%rbp)
movq %rdx, %rax
movq -0x58(%rbp), %rdx
movq %rax, -0x50(%rbp)
movl %esi, %eax
movq -0x50(%rbp), %rsi
movl %eax, -0x44(%rbp)
movq %rdi, %r8
movl -0x44(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movb %dil, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
je 0x2aa72
cmpb $0x0, -0x9(%rbp)
jne 0x2aa74
jmp 0x2aadc
movq -0x40(%rbp), %rdi
movb -0x9(%rbp), %sil
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %r8b
movb -0x22(%rbp), %r9b
leaq -0x30(%rbp), %r10
leaq -0x38(%rbp), %rax
andb $0x1, %r8b
andb $0x1, %r9b
movsbl %sil, %esi
movzbl %r8b, %r8d
movzbl %r9b, %r9d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x28c00
testb $0x1, %al
jne 0x2aabc
jmp 0x2aad3
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x2a7c0
jmp 0x2aadc
movq -0x40(%rbp), %rdi
callq 0x28040
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/./util_math.h
// Function: void AGS::Common::Math::ClampLength<unsigned long>(unsigned long&, unsigned long&, unsigned long const&, unsigned long const&)
inline void ClampLength(T &from, T &length, const T &floor, const T &height)
    {
        if (from < floor)
        {
            length -= floor - from;
            from = floor;
        }
        else if (from >= floor + height)
        {
            from = floor + height;
            length = 0;
        }

        length = Max<T>(length, 0);
        length = Min<T>(length, height - from);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2ac63
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
subq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2ac9f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
addq (%rdx), %rcx
cmpq %rcx, %rax
jb 0x2ac9d
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x2ac9f
movq -0x10(%rbp), %rdi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2ada0
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x2ab90
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/util_stream.cpp
// Function: AGS::Common::Stream::WriteByteCount(unsigned char, unsigned long)
size_t Stream::WriteByteCount(uint8_t b, size_t count)
{
    if (!CanWrite())
        return 0;
    size_t size = 0;
    for (; count > 0; --count, ++size)
    {
        if (WriteByte(b) < 0)
            break;
    }
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
callq *0x40(%rax)
testb $0x1, %al
jne 0x2bab2
movq $0x0, -0x8(%rbp)
jmp 0x2bafc
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x2baf4
movq -0x30(%rbp), %rdi
movb -0x11(%rbp), %cl
movq (%rdi), %rax
movzbl %cl, %esi
callq *0x68(%rax)
cmpl $0x0, %eax
jge 0x2bad8
jmp 0x2baf4
jmp 0x2bada
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2baba
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_compiler.cpp
// Function: ccAddDefaultHeader(char*, char*)
int ccAddDefaultHeader(char* nhead, char *nName)
{
    if (numheaders >= capacityHeaders)
    {
        capacityHeaders += 50;
        defaultheaders = (char**)realloc(defaultheaders, sizeof(char*) * capacityHeaders);
        defaultHeaderNames = (char**)realloc(defaultHeaderNames, sizeof(char*) * capacityHeaders);
    }

    defaultheaders[numheaders] = nhead;
    defaultHeaderNames[numheaders] = nName;
    numheaders++;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1cd22(%rip), %eax     # 0x48848
cmpl 0x1cd20(%rip), %eax     # 0x4884c
jl 0x2bb79
movl 0x1cd18(%rip), %eax     # 0x4884c
addl $0x32, %eax
movl %eax, 0x1cd0f(%rip)     # 0x4884c
movq 0x16f2c(%rip), %rdi     # 0x42a70
movslq 0x1cd01(%rip), %rsi     # 0x4884c
shlq $0x3, %rsi
callq 0x4620
movq %rax, 0x16f15(%rip)     # 0x42a70
movq 0x16f16(%rip), %rdi     # 0x42a78
movslq 0x1cce3(%rip), %rsi     # 0x4884c
shlq $0x3, %rsi
callq 0x4620
movq %rax, 0x16eff(%rip)     # 0x42a78
movq -0x8(%rbp), %rdx
movq 0x16eec(%rip), %rax     # 0x42a70
movslq 0x1ccbd(%rip), %rcx     # 0x48848
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movq 0x16ede(%rip), %rax     # 0x42a78
movslq 0x1cca7(%rip), %rcx     # 0x48848
movq %rdx, (%rax,%rcx,8)
movl 0x1cc9d(%rip), %eax     # 0x48848
addl $0x1, %eax
movl %eax, 0x1cc94(%rip)     # 0x48848
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::shutdown()
void MacroTable::shutdown() {
    int rr;
    for (rr=0;rr<num;rr++) {
        free(macro[rr]);
        free(name[rr]);
        macro[rr]=NULL;
        name[rr]=NULL;
    }
    num = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2c209
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x2ee8(%rax,%rcx,8), %rdi
callq 0x4460
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x4460
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x2ee8(%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2c1ab
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::add(char*, char*)
void MacroTable::add(char*namm,char*mac) {
    if (find_name(namm) >= 0) {
        cc_error("macro '%s' already defined",namm);
        return;
    }
    if (num>=MAXDEFINES) {
        cc_error("too many macros defined");
        return;
    }
    name[num]=(char*)malloc(strlen(namm)+5);
    strcpy(name[num],namm);
    macro[num]=(char*)malloc(strlen(mac)+5);
    strcpy(macro[num],mac);
    size_t l = strlen(mac);
    // remove trailing whitespace, newlines and the like.
    // if a macro ends with a newline (as usual when passed from parser)
    // this would otherwise cause the expanded macro to mess up reported
    // linenumbers.
    while(l > 0 && isspace(macro[num][l-1]))
        macro[num][--l] = 0;
    num++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2c3f0
cmpl $0x0, %eax
jl 0x2c2d1
movq -0x10(%rbp), %rsi
leaq 0x7e08(%rip), %rdi      # 0x340cd
movb $0x0, %al
callq 0x1bac0
jmp 0x2c3db
movq -0x28(%rbp), %rax
cmpl $0x5dc, (%rax)          # imm = 0x5DC
jl 0x2c2f0
leaq 0x7e04(%rip), %rdi      # 0x340e8
movb $0x0, %al
callq 0x1bac0
jmp 0x2c3db
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x5, %rdi
callq 0x44f0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movslq (%rax), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4350
movq -0x18(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x5, %rdi
callq 0x44f0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq %rdx, 0x2ee8(%rax,%rcx,8)
movslq (%rax), %rcx
movq 0x2ee8(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x4350
movq -0x18(%rbp), %rdi
callq 0x41d0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jbe 0x2c3a2
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq 0x2ee8(%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %edi
callq 0x40a0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2c3ab
jmp 0x2c3d0
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
movq 0x2ee8(%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, -0x1(%rax,%rcx)
jmp 0x2c36d
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::find_name(char*)
int MacroTable::find_name(char* namm) {
    int ss;
    for (ss=0;ss<num;ss++) {
        if (strcmp(namm,name[ss])==0) return ss;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2c44a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x2c43d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c451
jmp 0x2c43f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c40f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::remove(int)
void MacroTable::remove(int index) {
    if ((index < 0) || (index >= num)) {
        cc_error("MacroTable::Remove: index out of range");
        return;
    }
    // just blank out the entry, don't bother to remove it
    name[index][0] = 0;
    macro[index][0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x2c488
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jl 0x2c498
leaq 0x7c71(%rip), %rdi      # 0x34100
movb $0x0, %al
callq 0x1bac0
jmp 0x2c4b7
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
movb $0x0, (%rcx)
movslq -0xc(%rbp), %rcx
movq 0x2ee8(%rax,%rcx,8), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cs_prepro.cpp
// Function: directive_to_id(char*)
static int directive_to_id(char *dname) {
	for(int i = 0; i <= di_last; ++i)
		if(!ags_stricmp(dname, directives[i]))
			return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jg 0x2d04b
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x15448(%rip), %rax     # 0x42470
movq (%rax,%rcx,8), %rsi
callq 0x27a00
cmpl $0x0, %eax
jne 0x2d03e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d052
jmp 0x2d040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2d013
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/cs_prepro.cpp
// Function: pre_process_line(char*)
void pre_process_line(char*lin) {

  if (deletingCurrentLine()) {
    lin[0] = 0;
    return;
  }

  char*oldl=(char*)malloc(strlen(lin)+5);
  strcpy(oldl,lin);
  char*opt=oldl;
  char charBefore = 0;

  while (opt[0]!=0) {
    while (is_alphanum(opt[0])==0) {
      if (opt[0]==0) break;
      lin[0]=opt[0]; lin++; opt++; }

    if (opt > oldl)
      charBefore = opt[-1];
    else
      charBefore = 0;

    char thisword[MAX_LINE_LENGTH];
    get_next_word(opt,thisword);
    opt+=strlen(thisword);

    int fni = -1;
    if (charBefore != '.') {
      // object.member -- if member is a #define, it shouldn't be replaced
      fni = macros.find_name(thisword);
    }

    if (fni >= 0) {
      strcpy(lin,macros.macro[fni]);
      lin+=strlen(macros.macro[fni]);
    }
    else {
      strcpy(lin,thisword);
      lin+=strlen(thisword);
    }

  }
  free(oldl);
  lin[0]=0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movl 0x211e3(%rip), %eax     # 0x4e618
cmpl 0x211e1(%rip), %eax     # 0x4e61c
jle 0x2d449
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x2d5c4
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x5, %rdi
callq 0x44f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4350
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2d5b4
jmp 0x2d48d
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x26310
cmpl $0x0, %eax
jne 0x2d4d2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2d4ac
jmp 0x2d4d2
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d48d
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x2d4e8
movq -0x18(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x19(%rbp)
jmp 0x2d4ec
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x210(%rbp), %rsi
xorl %edx, %edx
callq 0x2c4c0
leaq -0x210(%rbp), %rdi
callq 0x41d0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x214(%rbp) # imm = 0xFFFFFFFF
movsbl -0x19(%rbp), %eax
cmpl $0x2e, %eax
je 0x2d53e
leaq -0x210(%rbp), %rsi
leaq 0x1b31d(%rip), %rdi     # 0x48850
callq 0x2c3f0
movl %eax, -0x214(%rbp)
cmpl $0x0, -0x214(%rbp)
jl 0x2d58b
movq -0x8(%rbp), %rdi
movslq -0x214(%rbp), %rcx
leaq 0x1b2f7(%rip), %rax     # 0x48850
movq 0x2ee8(%rax,%rcx,8), %rsi
callq 0x4350
movslq -0x214(%rbp), %rcx
leaq 0x1b2dc(%rip), %rax     # 0x48850
movq 0x2ee8(%rax,%rcx,8), %rdi
callq 0x41d0
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d5af
movq -0x8(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x4350
leaq -0x210(%rbp), %rdi
callq 0x41d0
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d47b
movq -0x10(%rbp), %rdi
callq 0x4460
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cs_prepro.cpp
// Function: cc_preprocess(char const*, char*)
void cc_preprocess(const char *inpu,char*outp) {
  reset_compiler();
  FMEM*temp=fmem_create();
  FMEM*iii=fmem_open(inpu);
  char linebuffer[1200];
  currentline=0;
  if_level = if_level_active = if_level_satisfied = 0;

  while (!fmem_eof(iii)) {
    fmem_gets(iii,linebuffer);
    currentline++;
    if (strlen(linebuffer) >= MAX_LINE_LENGTH) {  // stop array overflows in subroutines
      cc_error("line too long (%d chars max)", MAX_LINE_LENGTH);
      break; 
    }

    remove_comments(linebuffer);
    // need to check this, otherwise re-defining a macro causes
    // a big problem:
    // #define a int, #define a void  results in #define int void
    if (linebuffer[0]!='#')
      pre_process_line(linebuffer);
    if (ccError) break;
    if (linebuffer[0]=='#')
      pre_process_directive(linebuffer,temp);
    else {  // don't output the #define lines
//      printf("%s\n",linebuffer);
      fmem_puts(linebuffer,temp);
      }
    if (ccError) break;
    }

  strcpy(outp,temp->data);
  fmem_close(temp);
  fmem_close(iii);

  if ((if_level) && (!ccError))
    cc_error("missing #endif");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2d3f0
callq 0x24c50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24ce0
movq %rax, -0x20(%rbp)
leaq 0x1532b(%rip), %rax     # 0x42930
movl $0x0, (%rax)
movl $0x0, 0x2100b(%rip)     # 0x4e620
movl $0x0, 0x20ffd(%rip)     # 0x4e61c
movl $0x0, 0x20fef(%rip)     # 0x4e618
movq -0x20(%rbp), %rdi
callq 0x25020
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d643
jmp 0x2d704
movq -0x20(%rbp), %rdi
leaq -0x4d0(%rbp), %rsi
callq 0x25050
leaq 0x152d6(%rip), %rax     # 0x42930
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x152ca(%rip), %rax     # 0x42930
movl %ecx, (%rax)
leaq -0x4d0(%rbp), %rdi
callq 0x41d0
cmpq $0x1f4, %rax            # imm = 0x1F4
jb 0x2d691
leaq 0x6b9b(%rip), %rdi      # 0x3421e
movl $0x1f4, %esi            # imm = 0x1F4
movb $0x0, %al
callq 0x1bac0
jmp 0x2d704
leaq -0x4d0(%rbp), %rdi
callq 0x2d060
movsbl -0x4d0(%rbp), %eax
cmpl $0x23, %eax
je 0x2d6b5
leaq -0x4d0(%rbp), %rdi
callq 0x2d420
leaq 0x15194(%rip), %rax     # 0x42850
cmpl $0x0, (%rax)
je 0x2d6c3
jmp 0x2d704
movsbl -0x4d0(%rbp), %eax
cmpl $0x23, %eax
jne 0x2d6e1
leaq -0x4d0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c760
jmp 0x2d6f1
leaq -0x4d0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x24f00
leaq 0x15158(%rip), %rax     # 0x42850
cmpl $0x0, (%rax)
je 0x2d6ff
jmp 0x2d704
jmp 0x2d629
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4350
movq -0x18(%rbp), %rdi
callq 0x24d90
movq -0x20(%rbp), %rdi
callq 0x24d90
cmpl $0x0, 0x20eeb(%rip)     # 0x4e618
je 0x2d749
leaq 0x1511a(%rip), %rax     # 0x42850
cmpl $0x0, (%rax)
jne 0x2d749
leaq 0x6af9(%rip), %rdi      # 0x3423b
movb $0x0, %al
callq 0x1bac0
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_peek
int tokenizer_peek(struct tokenizer *t) {
	if(t->peeking) return t->peek_token.value;
	int ret = tokenizer_getc(t);
	if(ret != EOF) tokenizer_ungetc(t, ret);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2d835
movq -0x10(%rbp), %rax
movl 0x1184(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d859
movq -0x10(%rbp), %rdi
callq 0x2d870
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x2d853
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2d910
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_getc
static int tokenizer_getc(struct tokenizer *t)
{
	int c;
	if(t->getc_buf.buffered) {
		t->getc_buf.buffered--;
		c = t->getc_buf.buf[(t->getc_buf.cnt) % ARRAY_SIZE(t->getc_buf.buf)];
	} else {
		c = getc(t->input);
		t->getc_buf.buf[t->getc_buf.cnt % ARRAY_SIZE(t->getc_buf.buf)] = c;
	}
	++t->getc_buf.cnt;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1150(%rax)
je 0x2d8bf
movq -0x8(%rbp), %rax
movq 0x1150(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x1150(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1148(%rcx), %rcx
andq $0x7, %rcx
movl 0x1128(%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x2d8eb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4130
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1148(%rcx), %rcx
andq $0x7, %rcx
movl %edx, 0x1128(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x1148(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1148(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_ungetc
static int tokenizer_ungetc(struct tokenizer *t, int c)
{
	++t->getc_buf.buffered;
	assert(t->getc_buf.buffered<ARRAY_SIZE(t->getc_buf.buf));
	assert(t->getc_buf.cnt > 0);
	--t->getc_buf.cnt;
	assert(t->getc_buf.buf[t->getc_buf.cnt % ARRAY_SIZE(t->getc_buf.buf)] == c);
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1150(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1150(%rax)
movq -0x8(%rbp), %rax
cmpq $0x8, 0x1150(%rax)
jae 0x2d945
jmp 0x2d964
leaq 0x6c5d(%rip), %rdi      # 0x345a9
leaq 0x6ae1(%rip), %rsi      # 0x34434
movl $0x16, %edx
leaq 0x6c7b(%rip), %rcx      # 0x345da
callq 0x4290
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1148(%rax)
jbe 0x2d974
jmp 0x2d993
leaq 0x6c8d(%rip), %rdi      # 0x34608
leaq 0x6ab2(%rip), %rsi      # 0x34434
movl $0x17, %edx
leaq 0x6c4c(%rip), %rcx      # 0x345da
callq 0x4290
movq -0x8(%rbp), %rax
movq 0x1148(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x1148(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1148(%rcx), %rcx
andq $0x7, %rcx
movl 0x1128(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x2d9ca
jmp 0x2d9e9
leaq 0x6c4b(%rip), %rdi      # 0x3461c
leaq 0x6a5c(%rip), %rsi      # 0x34434
movl $0x19, %edx
leaq 0x6bf6(%rip), %rcx      # 0x345da
callq 0x4290
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_peek_token
int tokenizer_peek_token(struct tokenizer *t, struct token *tok) {
	int ret = tokenizer_next(t, tok);
	t->peek_token = *tok;
	t->peeking = 1;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2da60
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x1178(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x1180(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_register_custom_token
void tokenizer_register_custom_token(struct tokenizer*t, int tokentype, const char* str) {
	assert(tokentype >= TT_CUSTOM && tokentype < TT_CUSTOM + MAX_CUSTOM_TOKENS);
	int pos = tokentype - TT_CUSTOM;
	t->custom_tokens[pos] = str;
	if(pos+1 > t->custom_count) t->custom_count = pos+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jl 0x2dab7
cmpl $0x408, -0xc(%rbp)      # imm = 0x408
jge 0x2dab7
jmp 0x2dad6
leaq 0x6932(%rip), %rdi      # 0x343f0
leaq 0x696f(%rip), %rsi      # 0x34434
movl $0x39, %edx
leaq 0x696f(%rip), %rcx      # 0x34440
callq 0x4290
movl -0xc(%rbp), %eax
subl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jle 0x2db0e
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokentype_to_str
const char* tokentype_to_str(enum tokentype tt) {
	switch((unsigned) tt) {
		case TT_IDENTIFIER: return "iden";
		case TT_WIDECHAR_LIT: return "widechar";
		case TT_WIDESTRING_LIT: return "widestring";
		case TT_SQSTRING_LIT: return "single-quoted string";
		case TT_DQSTRING_LIT: return "double-quoted string";
		case TT_ELLIPSIS: return "ellipsis";
		case TT_HEX_INT_LIT: return "hexint";
		case TT_OCT_INT_LIT: return "octint";
		case TT_DEC_INT_LIT: return "decint";
		case TT_FLOAT_LIT: return "float";
		case TT_SEP: return "separator";
		case TT_UNKNOWN: return "unknown";
		case TT_OVERFLOW: return "overflow";
		case TT_EOF: return "eof";
	}
	return "????";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xd, %eax
ja 0x2dc14
movq -0x18(%rbp), %rax
leaq 0x676a(%rip), %rcx      # 0x342b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6936(%rip), %rax      # 0x3448c
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x692b(%rip), %rax      # 0x34491
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6924(%rip), %rax      # 0x3449a
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x691f(%rip), %rax      # 0x344a5
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6924(%rip), %rax      # 0x344ba
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6929(%rip), %rax      # 0x344cf
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6925(%rip), %rax      # 0x344d8
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x691f(%rip), %rax      # 0x344df
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6919(%rip), %rax      # 0x344e6
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x5dc3(%rip), %rax      # 0x3399d
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6906(%rip), %rax      # 0x344ed
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x6903(%rip), %rax      # 0x344f7
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x41fc(%rip), %rax      # 0x31dfd
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x68f1(%rip), %rax      # 0x344ff
movq %rax, -0x8(%rbp)
jmp 0x2dc1f
leaq 0x68e8(%rip), %rax      # 0x34503
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_skip_chars
int tokenizer_skip_chars(struct tokenizer *t, const char *chars, int *count) {
	assert(!t->peeking);
	int c;
	*count = 0;
	while(1) {
		c = tokenizer_getc(t);
		if(c == EOF) return 0;
		const char *s = chars;
		int match = 0;
		while(*s) {
			if(c==*s) {
				++(*count);
				match = 1;
				break;
			}
			++s;
		}
		if(!match) {
			tokenizer_ungetc(t, c);
			return 1;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x2dc50
jmp 0x2dc6f
leaq 0x68b1(%rip), %rdi      # 0x34508
leaq 0x67d6(%rip), %rsi      # 0x34434
movl $0x14f, %edx            # imm = 0x14F
leaq 0x68aa(%rip), %rcx      # 0x34514
callq 0x4290
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2d870
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x2dc94
movl $0x0, -0x4(%rbp)
jmp 0x2dcf9
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2dcdc
movl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2dcce
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, -0x34(%rbp)
jmp 0x2dcdc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2dca3
cmpl $0x0, -0x34(%rbp)
jne 0x2dcf7
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2d910
movl $0x1, -0x4(%rbp)
jmp 0x2dcf9
jmp 0x2dc79
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_read_until
int tokenizer_read_until(struct tokenizer *t, const char* marker, int stop_at_nl)
{
	int c, marker_is_nl = !strcmp(marker, "\n");
	char *s = t->buf;
	while(1) {
		c = tokenizer_getc(t);
		if(c == EOF) {
			*s = 0;
			return 0;
		}
		if(c == '\n') {
			t->line++;
			t->column = 0;
			if(stop_at_nl) {
				*s = 0;
				if(marker_is_nl) return 1;
				return 0;
			}
		}
		if(!sequence_follows(t, c, marker))
			s = assign_bufchar(t, s, c);
		else
			break;
	}
	*s = 0;
	size_t i;
	for(i=strlen(marker); i > 0; )
		tokenizer_ungetc(t, marker[--i]);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x643d(%rip), %rsi      # 0x3416b
callq 0x4510
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d870
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x2dd76
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2de35
cmpl $0xa, -0x20(%rbp)
jne 0x2ddbe
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x2ddbc
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x2ddb3
movl $0x1, -0x4(%rbp)
jmp 0x2de35
movl $0x0, -0x4(%rbp)
jmp 0x2de35
jmp 0x2ddbe
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2de40
cmpl $0x0, %eax
jne 0x2dde9
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x2df10
movq %rax, -0x30(%rbp)
jmp 0x2ddeb
jmp 0x2ddf0
jmp 0x2dd51
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x41d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x2de2e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movsbl -0x1(%rax,%rcx), %esi
callq 0x2d910
jmp 0x2de04
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/tokenizer.c
// Function: sequence_follows
static int sequence_follows(struct tokenizer *t, int c, const char *which)
{
	if(!which || !which[0]) return 0;
	size_t i = 0;
	while(c == which[i]) {
		if(!which[++i]) break;
		c = tokenizer_getc(t);
	}
	if(!which[i]) return 1;
	while(i > 0) {
		tokenizer_ungetc(t, c);
		c = which[--i];
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2de63
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2de6f
movl $0x0, -0x4(%rbp)
jmp 0x2df04
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2deb4
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
jne 0x2dea6
jmp 0x2deb4
movq -0x10(%rbp), %rdi
callq 0x2d870
movl %eax, -0x14(%rbp)
jmp 0x2de77
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x2decb
movl $0x1, -0x4(%rbp)
jmp 0x2df04
jmp 0x2decd
cmpq $0x0, -0x28(%rbp)
jbe 0x2defd
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2d910
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movsbl -0x1(%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0x2decd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: ignore_until
static int ignore_until(struct tokenizer *t, const char* marker, int col_advance)
{
	t->column += col_advance;
	int c;
	do {
		c = tokenizer_getc(t);
		if(c == EOF) return 0;
		if(c == '\n') {
			t->line++;
			t->column = 0;
		} else t->column++;
	} while(!sequence_follows(t, c, marker));
	t->column += strlen(marker)-1;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x2d870
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x2dfbb
movl $0x0, -0x4(%rbp)
jmp 0x2e02a
cmpl $0xa, -0x20(%rbp)
jne 0x2dfdb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x2dfe8
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x2dfea
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2de40
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2dfa0
movq -0x18(%rbp), %rdi
callq 0x41d0
movq %rax, %rdx
subq $0x1, %rdx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_valid_float_until
static int is_valid_float_until(const char*s, const char* until) {
	int got_digits = 0, got_dot = 0;
	while(s < until) {
		if(isdigit(*s)) got_digits = 1;
		else if(*s == '.') {
			if(got_dot) return 0;
			got_dot = 1;
		} else return 0;
		++s;
	}
	return got_digits | (got_dot << 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2e78e
callq 0x4400
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2e751
movl $0x1, -0x1c(%rbp)
jmp 0x2e780
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2e775
cmpl $0x0, -0x20(%rbp)
je 0x2e76c
movl $0x0, -0x4(%rbp)
jmp 0x2e79b
movl $0x1, -0x20(%rbp)
jmp 0x2e77e
movl $0x0, -0x4(%rbp)
jmp 0x2e79b
jmp 0x2e780
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2e71e
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)