LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ThePhage[P]horse_tornado/fast.cpp
// Function: (anonymous namespace)::async(std::function<void ()> const&)
void async(const function<void()>& f) {
  const auto p = new function<void()>(f);
  pthread_t thread;
  const int r = pthread_create(&thread,0,[](void* arg) {
    const auto p = (function<void()>*)arg;
    (*p)();
    delete p;
    return (void*)0;
  },p);
  if (r)
    die(string("Thread creation failed: ")+strerror(r));
  pthread_detach(thread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x7610
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rsi
callq 0x192a0
jmp 0x9c4e
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0xc840
movq %rax, %rdx
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7a30
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x9d2f
leaq -0x71(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x79e0
movq -0x88(%rbp), %rdx
leaq 0x1eec1(%rip), %rsi     # 0x28b5f
leaq -0x70(%rbp), %rdi
callq 0x11520
jmp 0x9ca9
movl -0x2c(%rbp), %edi
callq 0x71e0
movq %rax, %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x114d0
jmp 0x9cc3
leaq -0x50(%rbp), %rdi
callq 0x87f0
jmp 0x9cce
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x7620
jmp 0x9d41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x9d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x9d1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7380
leaq -0x70(%rbp), %rdi
callq 0x7380
leaq -0x71(%rbp), %rdi
callq 0x7680
jmp 0x9d41
movq -0x28(%rbp), %rdi
callq 0x7440
addq $0x90, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x79d0
nopw (%rax,%rax)
// File: ThePhage[P]horse_tornado/fast.cpp
// Function: (anonymous namespace)::good_sleep(double)
void good_sleep(const double t) {
  if (t <= 0)
    return;
  const uint64_t b = 1000000000;
  const uint64_t n(b*t);
  timespec ts;
  ts.tv_sec = n/b;
  ts.tv_nsec = n%b;
  nanosleep(&ts,0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jb 0xa089
jmp 0xa0fd
movq $0x3b9aca00, -0x10(%rbp) # imm = 0x3B9ACA00
movsd -0x8(%rbp), %xmm0
movsd 0x1df7a(%rip), %xmm1    # 0x28018
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1df67(%rip), %xmm1    # 0x28020
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ThePhage[P]horse_tornado/fast.cpp
// Function: (anonymous namespace)::join(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
string join(const string& sep, const vector<string>& args) {
  string result;
  for (size_t i=0;i<args.size();i++) {
    if (i) result += sep;
    result += args[i];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7820
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26380
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xfd07
cmpq $0x0, -0x28(%rbp)
je 0xfcdc
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7790
jmp 0xfcc3
jmp 0xfcdc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7380
jmp 0xfd24
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x263a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7790
jmp 0xfcf7
jmp 0xfcf9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfc90
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xfd1a
movq -0x48(%rbp), %rdi
callq 0x7380
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x79d0
nopl (%rax)
// File: ThePhage[P]horse_tornado/fast.cpp
// Function: (anonymous namespace)::run(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void run(const vector<string>& cmd) {
  const pid_t pid = fork();
  if (pid) { // Parent
    int status;
    waitpid(pid,&status,0);
    if (!WIFEXITED(status) || WEXITSTATUS(status))
      exit(1);
  } else // Child
    exec(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7180
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xfd7f
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x74f0
movl -0x10(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xfd73
movl -0x10(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0xfd7d
movl $0x1, %edi
callq 0x7750
jmp 0xfd88
movq -0x8(%rbp), %rdi
callq 0xf990
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/main.cpp
// Function: prepare_default_conf()
void prepare_default_conf()
{
    LEAF::CONF::Conf &conf = LEAF::CONF::ConfManager::get();

    //generator
    conf.set<char *>("leaf.compiler.generator.outfile", "test/leaf.asm");

    //sections; grupo: leaf.compiler.asm.section.
    conf.set<bool>("leaf.compiler.asm.section.show_title", true); //general
    conf.set<bool>("leaf.compiler.asm.section.text.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.data.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.bss.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.extern.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.global.title.show", true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xe860
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2979a(%rip), %rsi     # 0x34036
leaq 0x297b3(%rip), %rdx     # 0x34056
callq 0xaf70
movq -0x8(%rbp), %rdi
leaq 0x297b1(%rip), %rsi     # 0x34064
movl $0x1, %edx
callq 0xafa0
movq -0x8(%rbp), %rdi
leaq 0x297c1(%rip), %rsi     # 0x34089
movl $0x1, %edx
callq 0xafa0
movq -0x8(%rbp), %rdi
leaq 0x297d6(%rip), %rsi     # 0x340b3
movl $0x1, %edx
callq 0xafa0
movq -0x8(%rbp), %rdi
leaq 0x297eb(%rip), %rsi     # 0x340dd
movl $0x1, %edx
callq 0xafa0
movq -0x8(%rbp), %rdi
leaq 0x297ff(%rip), %rsi     # 0x34106
movl $0x1, %edx
callq 0xafa0
movq -0x8(%rbp), %rdi
leaq 0x29816(%rip), %rsi     # 0x34132
movl $0x1, %edx
callq 0xafa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/ast/expressions.cpp
// Function: LEAF::AST::BinOp::BinOp(LEAF::AST::NODEU*, LEAF::AST::op_types, LEAF::AST::NODEU*)
BinOp::BinOp(ASTU l, op_types op, ASTU r)
{
    this->l = l;
    this->r = r;
    this->op = op;
    //obj->type=left->obj->type;
    this->obj->type = l->obj->type;

    //TODO: codigo para la coercion de tipos aritmeticos
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xc020
movq -0x28(%rbp), %rax
leaq 0x3c939(%rip), %rcx     # 0x489c8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/ast/statement.hpp
// Function: LEAF::AST::rand_label::newLabel[abi:cxx11](int)
static string *newLabel(int size)
    {

        char *r = (char *)malloc(sizeof(char) * size + 2);
        r[0] = '_';
        string tokens("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_");
        for (int x = 1; x < size-1; x++)
        {

            r[x] = tokens[rand() % 63];
        }
        r[size - 1] = '_';
        r[size] = '\0';
        return new string(r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
addq $0x2, %rdi
callq 0x6420
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x5f, (%rax)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6500
movq -0x58(%rbp), %rdx
leaq 0x2795b(%rip), %rsi     # 0x34279
leaq -0x30(%rbp), %rdi
callq 0xada0
jmp 0xc929
leaq -0x31(%rbp), %rdi
callq 0x6340
movl $0x1, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc9cb
callq 0x60c0
movslq %eax, %rcx
imulq $-0x7df7df7d, %rcx, %rcx # imm = 0x82082083
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x6, %edx
subl %edx, %ecx
addl %ecx, %eax
movslq %eax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6570
movq %rax, -0x60(%rbp)
jmp 0xc984
movq -0x60(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xc939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6340
jmp 0xca7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xca73
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
decl %ecx
movslq %ecx, %rcx
movb $0x5f, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x68(%rbp)
jmp 0xc9f7
movb $0x1, -0x4a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6500
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0xada0
jmp 0xca23
movb $0x0, -0x4a(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6340
leaq -0x30(%rbp), %rdi
callq 0x6588
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6340
testb $0x1, -0x4a(%rbp)
jne 0xca63
jmp 0xca71
movq -0x68(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0xca73
leaq -0x30(%rbp), %rdi
callq 0x6588
movq -0x40(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nop
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(wchar_t const*, int)
wchar_t* coco_string_create(const wchar_t *value, int startIndex) {
	int valueLen = 0;
	int len = 0;

	if (value) {
		valueLen = wcslen(value);
		len = valueLen - startIndex;
	}

	return coco_string_create(value, startIndex, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeb89
movq -0x8(%rbp), %rdi
callq 0x6250
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xeba0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(wchar_t const*, int, int)
wchar_t* coco_string_create(const wchar_t *value, int startIndex, int length) {
	int len = 0;
	wchar_t* data;

	if (value) { len = length; }
	data = new wchar_t[len + 1];
	wcsncpy(data, &(value[startIndex]), len);
	data[len] = 0;

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xebc6
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x60b0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_upper(wchar_t const*)
wchar_t* coco_string_create_upper(const wchar_t* data) {
	if (!data) { return NULL; }

	int dataLen = 0;
	if (data) { dataLen = wcslen(data); }

	wchar_t *newData = new wchar_t[dataLen + 1];

	for (int i = 0; i <= dataLen; i++) {
		if ((L'a' <= data[i]) && (data[i] <= L'z')) {
			newData[i] = data[i] + (L'A' - L'a');
		}
		else { newData[i] = data[i]; }
	}

	newData[dataLen] = L'\0';
	return newData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xec50
movq $0x0, -0x8(%rbp)
jmp 0xed1b
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xec6a
movq -0x10(%rbp), %rdi
callq 0x6250
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xed04
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movl $0x61, %eax
cmpl (%rcx,%rdx,4), %eax
jg 0xece1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x7a, (%rax,%rcx,4)
jg 0xece1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x20, %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xecf7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xecf9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xec9e
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_lower(wchar_t const*, int, int)
wchar_t* coco_string_create_lower(const wchar_t* data, int startIndex, int dataLen) {
	if (!data) { return NULL; }

	wchar_t* newData = new wchar_t[dataLen + 1];

	for (int i = 0; i <= dataLen; i++) {
		wchar_t ch = data[startIndex + i];
		if ((L'A' <= ch) && (ch <= L'Z')) {
			newData[i] = ch - (L'A' - L'a');
		}
		else { newData[i] = ch; }
	}
	newData[dataLen] = L'\0';
	return newData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xeda6
movq $0x0, -0x8(%rbp)
jmp 0xee4a
movl -0x18(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xee33
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl $0x41, %eax
cmpl -0x28(%rbp), %eax
jg 0xee18
cmpl $0x5a, -0x28(%rbp)
jg 0xee18
movl -0x28(%rbp), %edx
subl $-0x20, %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xee26
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xee28
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xedda
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_append(wchar_t const*, wchar_t const*)
wchar_t* coco_string_create_append(const wchar_t* data1, const wchar_t* data2) {
	wchar_t* data;
	int data1Len = 0;
	int data2Len = 0;

	if (data1) { data1Len = wcslen(data1); }
	if (data2) {data2Len = wcslen(data2); }

	data = new wchar_t[data1Len + data2Len + 1];

	if (data1) { wcscpy(data, data1); }
	if (data2) { wcscpy(data + data1Len, data2); }

	data[data1Len + data2Len] = 0;

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xee91
movq -0x8(%rbp), %rdi
callq 0x6250
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeea4
movq -0x10(%rbp), %rdi
callq 0x6250
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeee8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6530
cmpq $0x0, -0x10(%rbp)
je 0xef07
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6530
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_append(wchar_t const*, wchar_t)
wchar_t* coco_string_create_append(const wchar_t *target, const wchar_t appendix) {
	int targetLen = coco_string_length(target);
	wchar_t* data = new wchar_t[targetLen + 2];
	wcsncpy(data, target, targetLen);
	data[targetLen] = appendix;
	data[targetLen + 1] = 0;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xefc0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x60b0
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_merge(wchar_t*&, wchar_t const*)
void coco_string_merge(wchar_t* &target, const wchar_t* appendix) {
	if (!appendix) { return; }
	wchar_t* data = coco_string_create_append(target, appendix);
	delete [] target;
	target = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf179
jmp 0xf1b2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xee60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf1a7
movq -0x20(%rbp), %rdi
callq 0x6400
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_hash(wchar_t const*)
int coco_string_hash(const wchar_t *data) {
	int h = 0;
	if (!data) { return 0; }
	while (*data != 0) {
		h = (h * 7) ^ *data;
		++data;
	}
	if (h < 0) { h = -h; }
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf23f
movl $0x0, -0x4(%rbp)
jmp 0xf279
jmp 0xf241
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xf265
imull $0x7, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl (%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xf241
cmpl $0x0, -0x14(%rbp)
jge 0xf273
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(char const*)
wchar_t* coco_string_create(const char* value) {
	int len = 0;
	if (value) { len = strlen(value); }
	wchar_t* data = new wchar_t[len + 1];
	for (int i = 0; i < len; ++i) { data[i] = (wchar_t) value[i]; }
	data[len] = 0;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf2a6
movq -0x8(%rbp), %rdi
callq 0x6140
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xf304
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf2da
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_char(wchar_t const*)
char* coco_string_create_char(const wchar_t *value) {
	int len = coco_string_length(value);
	char *res = new char[len + 1];
	for (int i = 0; i < len; ++i) { res[i] = (char) value[i]; }
	res[len] = 0;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xefc0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x6040
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xf37c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf351
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Token::Token()
Token::Token() {
	kind = 0;
	pos  = 0;
	col  = 0;
	line = 0;
	val  = NULL;
	next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(_IO_FILE*, bool)
Buffer::Buffer(FILE* s, bool isUserStream) {
// ensure binary read on windows
#if _MSC_VER >= 1300
	_setmode(_fileno(s), _O_BINARY);
#endif
	stream = s; this->isUserStream = isUserStream;
	if (CanSeek()) {
		fseek(s, 0, SEEK_END);
		fileLen = ftell(s);
		fseek(s, 0, SEEK_SET);
		bufLen = (fileLen < COCO_MAX_BUFFER_LENGTH) ? fileLen : COCO_MAX_BUFFER_LENGTH;
		bufStart = INT_MAX; // nothing in the buffer so far
	} else {
		fileLen = bufLen = bufStart = 0;
	}
	bufCapacity = (bufLen>0) ? bufLen : COCO_MIN_BUFFER_LENGTH;
	buf = new unsigned char[bufCapacity];	
	if (fileLen > 0) SetPos(0);          // setup  buffer to position 0 (start)
	else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
	if (bufLen == fileLen && CanSeek()) Close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x39aea(%rip), %rax     # 0x48f50
addq $0x10, %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x28(%rdi)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, 0x30(%rdi)
callq 0xf5a0
testb $0x1, %al
jne 0xf488
jmp 0xf4f2
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x6380
movq -0x10(%rbp), %rdi
callq 0x6030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6380
movq -0x20(%rbp), %rax
cmpl $0x10000, 0x1c(%rax)    # imm = 0x10000
jge 0xf4d5
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xf4df
movl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x24(%rbp)
jmp 0xf4df
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl $0x7fffffff, 0x14(%rax) # imm = 0x7FFFFFFF
jmp 0xf50b
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0xf521
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0xf52b
movl $0x400, %eax            # imm = 0x400
movl %eax, -0x28(%rbp)
jmp 0xf52b
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, 0x10(%rax)
movslq 0x10(%rax), %rdi
callq 0x6040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x0, 0x1c(%rax)
jle 0xf55d
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
jmp 0xf568
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0xf58d
movq -0x20(%rbp), %rdi
callq 0xf5a0
testb $0x1, %al
jne 0xf583
jmp 0xf58d
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(Buffer*)
Buffer::Buffer(Buffer *b) {
	buf = b->buf;
	bufCapacity = b->bufCapacity;
	b->buf = NULL;
	bufStart = b->bufStart;
	bufLen = b->bufLen;
	fileLen = b->fileLen;
	bufPos = b->bufPos;
	stream = b->stream;
	b->stream = NULL;
	isUserStream = b->isUserStream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x39949(%rip), %rcx     # 0x48f50
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, 0x28(%rcx)
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(unsigned char const*, int)
Buffer::Buffer(const unsigned char* buf, int len) {
	this->buf = new unsigned char[len];
	memcpy(this->buf, buf, len*sizeof(unsigned char));
	bufStart = 0;
	bufCapacity = bufLen = len;
	fileLen = len;
	bufPos = 0;
	stream = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x398ae(%rip), %rcx     # 0x48f50
addq $0x10, %rcx
movq %rcx, (%rax)
movslq -0x14(%rbp), %rdi
callq 0x6040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x0, %rdx
callq 0x6230
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::~Buffer()
Buffer::~Buffer() {
	Close(); 
	if (buf != NULL) {
		delete [] buf;
		buf = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x39835(%rip), %rax     # 0x48f60
movq %rax, (%rdi)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xf739
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf76b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xf75f
movq -0x18(%rbp), %rdi
callq 0x6400
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb4a0
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Read()
int Buffer::Read() {
	if (bufPos < bufLen) {
		return buf[bufPos++];
	} else if (GetPos() < fileLen) {
		SetPos(GetPos()); // shift buffer start to Pos
		return buf[bufPos++];
	} else if ((stream != NULL) && !CanSeek() && (ReadNextStreamChunk() > 0)) {
		return buf[bufPos++];
	} else {
		return EoF;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x20(%rcx), %eax
cmpl 0x18(%rcx), %eax
jge 0xf83e
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8d2
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0xf886
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x18(%rbp), %rdi
movl %eax, %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8d2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xf8cb
movq -0x18(%rbp), %rdi
callq 0xf5a0
testb $0x1, %al
jne 0xf8cb
movq -0x18(%rbp), %rdi
callq 0xf8e0
cmpl $0x0, %eax
jle 0xf8cb
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8d2
movl $0x10000, -0x4(%rbp)    # imm = 0x10000
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::ReadNextStreamChunk()
int Buffer::ReadNextStreamChunk() {
	int free = bufCapacity - bufLen;
	if (free == 0) {
		// in the case of a growing input stream
		// we can neither seek in the stream, nor can we
		// foresee the maximum length, thus we must adapt
		// the buffer size on demand.
		bufCapacity = bufLen * 2;
		unsigned char *newBuf = new unsigned char[bufCapacity];
		memcpy(newBuf, buf, bufLen*sizeof(unsigned char));
		delete [] buf;
		buf = newBuf;
		free = bufLen;
	}
	int read = fread(buf + bufLen, sizeof(unsigned char), free, stream);
	if (read > 0) {
		fileLen = bufLen = (bufLen + read);
		return read;
	}
	// end of stream reached
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0x10(%rcx), %eax
subl 0x18(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xf965
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
movslq 0x10(%rax), %rdi
callq 0x6040
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x8(%rax), %rsi
movslq 0x18(%rax), %rdx
shlq $0x0, %rdx
callq 0x6230
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xf953
movq -0x38(%rbp), %rdi
callq 0x6400
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rcx
addq %rcx, %rdi
movslq -0x14(%rbp), %rdx
movq 0x28(%rax), %rcx
movl $0x1, %esi
callq 0x6480
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0xf9a7
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl %ecx, 0x1c(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf9ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Peek()
int Buffer::Peek() {
	int curPos = GetPos();
	int ch = Read();
	SetPos(curPos);
	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::GetString(int, int)
wchar_t* Buffer::GetString(int beg, int end) {
	int len = 0;
	wchar_t *buf = new wchar_t[end - beg];
	int oldPos = GetPos();
	SetPos(beg);
	while (GetPos() < end) buf[len++] = (wchar_t) Read();
	SetPos(oldPos);
	wchar_t *res = coco_string_create(buf, 0, len);
	coco_string_delete(buf);
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl -0x10(%rbp), %eax
jge 0xfa9a
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %edx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xfa68
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0xeba0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf000
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::SetPos(int)
void Buffer::SetPos(int value) {
	if ((value >= fileLen) && (stream != NULL) && !CanSeek()) {
		// Wanted position is after buffer and the stream
		// is not seek-able e.g. network or console,
		// thus we have to read the stream manually till
		// the wanted position is in sight.
		while ((value >= fileLen) && (ReadNextStreamChunk() > 0));
	}

	if ((value < 0) || (value > fileLen)) {
		printf("--- buffer out of bounds access, position: %d\n", value);
		exit(1);
	}

	if ((value >= bufStart) && (value < (bufStart + bufLen))) { // already in buffer
		bufPos = value - bufStart;
	} else if (stream != NULL) { // must be swapped in
		fseek(stream, value, SEEK_SET);
		bufLen = fread(buf, sizeof(unsigned char), bufCapacity, stream);
		bufStart = value; bufPos = 0;
	} else {
		bufPos = fileLen - bufStart; // make Pos return fileLen
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jl 0xfb59
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xfb59
movq -0x18(%rbp), %rdi
callq 0xf5a0
testb $0x1, %al
jne 0xfb59
jmp 0xfb29
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x1c(%rdx), %ecx
movb %al, -0x19(%rbp)
jl 0xfb4c
movq -0x18(%rbp), %rdi
callq 0xf8e0
cmpl $0x0, %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xfb55
jmp 0xfb57
jmp 0xfb29
jmp 0xfb59
cmpl $0x0, -0xc(%rbp)
jl 0xfb6b
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jle 0xfb86
movl -0xc(%rbp), %esi
leaq 0x24a0c(%rip), %rdi     # 0x34581
movb $0x0, %al
callq 0x6070
movl $0x1, %edi
callq 0x63d0
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jl 0xfbb2
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0x14(%rdx), %ecx
addl 0x18(%rdx), %ecx
cmpl %ecx, %eax
jge 0xfbb2
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl 0x14(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0xfc12
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xfc03
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x6380
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rdx
movq 0x28(%rax), %rcx
movl $0x1, %esi
callq 0x6480
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl $0x0, 0x20(%rax)
jmp 0xfc10
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
subl 0x14(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0xfc12
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Scanner(wchar_t const*)
Scanner::Scanner(const wchar_t* fileName) {
	FILE* stream;
	char *chFileName = coco_string_create_char(fileName);
	if ((stream = fopen(chFileName, "rb")) == NULL) {
		printf("--- Cannot open file %ls\n", fileName);
		exit(1);
	}
	coco_string_delete(chFileName);
	buffer = new Buffer(stream, false);
	Init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
callq 0x12590
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x38(%rbp)
callq 0x125e0
jmp 0x105b8
movq -0x10(%rbp), %rdi
callq 0xf320
movq %rax, -0x50(%rbp)
jmp 0x105c7
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x23fd6(%rip), %rsi     # 0x345b0
callq 0x63b0
movq %rax, -0x58(%rbp)
jmp 0x105e5
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1062d
movq -0x10(%rbp), %rsi
leaq 0x23fb5(%rip), %rdi     # 0x345b3
xorl %eax, %eax
callq 0x6070
jmp 0x10607
movl $0x1, %edi
callq 0x63d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10696
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1068d
leaq -0x30(%rbp), %rdi
callq 0xf3a0
movl $0x38, %edi
callq 0x62e0
movq %rax, -0x60(%rbp)
jmp 0x10646
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xf440
jmp 0x10657
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, 0x98(%rdi)
callq 0xfe80
jmp 0x1066d
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x38, %esi
callq 0x62f0
movq -0x38(%rbp), %rdi
callq 0x12630
movq -0x48(%rbp), %rdi
callq 0x126e0
movq -0x18(%rbp), %rdi
callq 0x64f0
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::~Scanner()
Scanner::~Scanner() {
	char* cur = (char*) firstHeap;

	while(cur != NULL) {
		cur = *(char**) (cur + COCO_HEAP_BLOCK_SIZE);
		free(firstHeap);
		firstHeap = cur;
	}
	delete [] tval;
	delete buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x107ca
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x4000000(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0x63c0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1079b
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x107e5
movq -0x20(%rbp), %rdi
callq 0x6400
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x10804
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x12630
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x126e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::NextCh()
void Scanner::NextCh() {
	if (oldEols > 0) { ch = EOL; oldEols--; }
	else {
		pos = buffer->GetPos();
		// buffer reads unicode chars, if UTF8 has been detected
		ch = buffer->Read(); col++; charPos++;
		// replace isolated '\r' by '\n' in order to make
		// eol handling uniform across Windows, Unix and Mac
		if (ch == L'\r' && buffer->Peek() != L'\n') ch = EOL;
		if (ch == EOL) { line++; col = 0; }
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x94(%rax)
jle 0x1086f
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
movl %ecx, 0x80(%rax)
movl 0x94(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x94(%rax)
jmp 0x10921
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x84(%rax)
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x80(%rax)
movl 0x90(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x90(%rax)
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
cmpl $0xd, 0x80(%rax)
jne 0x108f0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0xa, %eax
je 0x108f0
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
movl %ecx, 0x80(%rax)
movq -0x10(%rbp), %rcx
movl 0x80(%rcx), %eax
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1091f
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
movl $0x0, 0x90(%rax)
jmp 0x10921
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::CreateToken()
Token* Scanner::CreateToken() {
	Token *t;
	if (((char*) heapTop + (int) sizeof(Token)) >= (char*) heapEnd) {
		CreateHeapBlock();
	}
	t = (Token*) heapTop;
	heapTop = (void*) ((char*) heapTop + sizeof(Token));
	t->val = NULL;
	t->next = NULL;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rcx), %rax
addq $0x28, %rax
cmpq 0x18(%rcx), %rax
jb 0x1095b
movq -0x18(%rbp), %rdi
callq 0x10e60
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rcx
addq $0x28, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::AddCh()
void Scanner::AddCh() {
	if (tlen >= tvalLength) {
		tvalLength *= 2;
		wchar_t *newBuf = new wchar_t[tvalLength];
		memcpy(newBuf, tval, tlen*sizeof(wchar_t));
		delete [] tval;
		tval = newBuf;
	}
	if (ch != Buffer::EoF) {
		tval[tlen++] = ch;
		NextCh();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x6c(%rcx), %eax
cmpl 0x68(%rcx), %eax
jl 0x10a34
movq -0x18(%rbp), %rax
movl 0x68(%rax), %ecx
shll %ecx
movl %ecx, 0x68(%rax)
movslq 0x68(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x60(%rax), %rsi
movslq 0x6c(%rax), %rdx
shlq $0x2, %rdx
callq 0x6230
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x10a28
movq -0x20(%rbp), %rdi
callq 0x6400
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
cmpl $0x10000, 0x80(%rax)    # imm = 0x10000
je 0x10a68
movq -0x18(%rbp), %rdi
movl 0x80(%rdi), %edx
movq 0x60(%rdi), %rax
movl 0x6c(%rdi), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x6c(%rdi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
callq 0x10830
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Comment0()
bool Scanner::Comment0() {
	int level = 1, pos0 = pos, line0 = line, col0 = col, charPos0 = charPos;
	NextCh();
	if (ch == L'/') {
		NextCh();
		for(;;) {
			if (ch == 10) {
				level--;
				if (level == 0) { oldEols = line - line0; NextCh(); return true; }
				NextCh();
			} else if (ch == buffer->EoF) return false;
			else NextCh();
		}
	} else {
		buffer->SetPos(pos0); NextCh(); line = line0; col = col0; charPos = charPos0;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x1, -0x14(%rbp)
movl 0x84(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0x8c(%rdi), %eax
movl %eax, -0x1c(%rbp)
movl 0x90(%rdi), %eax
movl %eax, -0x20(%rbp)
movl 0x88(%rdi), %eax
movl %eax, -0x24(%rbp)
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0x2f, 0x80(%rax)
jne 0x10b32
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0xa, 0x80(%rax)
jne 0x10b0f
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x10b04
movq -0x30(%rbp), %rdi
movl 0x8c(%rdi), %eax
subl -0x1c(%rbp), %eax
movl %eax, 0x94(%rdi)
callq 0x10830
movb $0x1, -0x1(%rbp)
jmp 0x10b72
movq -0x30(%rbp), %rdi
callq 0x10830
jmp 0x10b30
movq -0x30(%rbp), %rax
cmpl $0x10000, 0x80(%rax)    # imm = 0x10000
jne 0x10b25
movb $0x0, -0x1(%rbp)
jmp 0x10b72
movq -0x30(%rbp), %rdi
callq 0x10830
jmp 0x10b30
jmp 0x10aca
movq -0x30(%rbp), %rax
movq 0x98(%rax), %rdi
movl -0x18(%rbp), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x90(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x88(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Comment1()
bool Scanner::Comment1() {
	int level = 1, pos0 = pos, line0 = line, col0 = col, charPos0 = charPos;
	NextCh();
	if (ch == L'*') {
		NextCh();
		for(;;) {
			if (ch == L'*') {
				NextCh();
				if (ch == L')') {
					level--;
					if (level == 0) { oldEols = line - line0; NextCh(); return true; }
					NextCh();
				}
			} else if (ch == L'(') {
				NextCh();
				if (ch == L'*') {
					level++; NextCh();
				}
			} else if (ch == buffer->EoF) return false;
			else NextCh();
		}
	} else {
		buffer->SetPos(pos0); NextCh(); line = line0; col = col0; charPos = charPos0;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x1, -0x14(%rbp)
movl 0x84(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0x8c(%rdi), %eax
movl %eax, -0x1c(%rbp)
movl 0x90(%rdi), %eax
movl %eax, -0x20(%rbp)
movl 0x88(%rdi), %eax
movl %eax, -0x24(%rbp)
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0x2a, 0x80(%rax)
jne 0x10c9b
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0x2a, 0x80(%rax)
jne 0x10c3c
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0x29, 0x80(%rax)
jne 0x10c3a
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x10c31
movq -0x30(%rbp), %rdi
movl 0x8c(%rdi), %eax
subl -0x1c(%rbp), %eax
movl %eax, 0x94(%rdi)
callq 0x10830
movb $0x1, -0x1(%rbp)
jmp 0x10cdb
movq -0x30(%rbp), %rdi
callq 0x10830
jmp 0x10c96
movq -0x30(%rbp), %rax
cmpl $0x28, 0x80(%rax)
jne 0x10c73
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
cmpl $0x2a, 0x80(%rax)
jne 0x10c71
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
callq 0x10830
jmp 0x10c94
movq -0x30(%rbp), %rax
cmpl $0x10000, 0x80(%rax)    # imm = 0x10000
jne 0x10c89
movb $0x0, -0x1(%rbp)
jmp 0x10cdb
movq -0x30(%rbp), %rdi
callq 0x10830
jmp 0x10c94
jmp 0x10c96
jmp 0x10bde
movq -0x30(%rbp), %rax
movq 0x98(%rax), %rdi
movl -0x18(%rbp), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x30(%rbp), %rdi
callq 0x10830
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x90(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x88(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)