LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Diagnostic::demangle[abi:cxx11](char const*)
static std::string demangle(const char* typeinfo_name) {
#if defined(__clang__) || defined(__GLIBCXX__) || defined(__GLIBCPP__)
      int status = 0;
      char* demangled =
        abi::__cxa_demangle(typeinfo_name, nullptr, nullptr, &status);
      if (status == 0) {
        std::string result = demangled;
        std::free(demangled);
        return result;
      }
      else {
        return typeinfo_name;
      }
#else
      return typeinfo_name;
#endif  // defined(__clang__) || defined(__GLIBCXX__) || defined(__GLIBCPP__)
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x21b0
cmpl $0x0, (%r12)
je 0x4491
leaq 0x2(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2696
jmp 0x44ac
movq %rax, %r15
leaq 0x3(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2696
movq %r15, %rdi
callq 0x2240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x904e
movq %rax, %rbx
leaq 0x115d7(%rip), %rax     # 0x19022
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x115ea(%rip), %rax     # 0x19042
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x115e2(%rip), %rax     # 0x19050
movq %rax, (%r14)
movl $0x1, %r15d
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x115e5(%rip), %rax     # 0x19075
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x115f3(%rip), %rax     # 0x1909f
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x11601(%rip), %rax     # 0x190c9
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x1160e(%rip), %rax     # 0x190f2
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ddc
leaq 0x1161e(%rip), %rax     # 0x1911e
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7ddc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq %edi, %r14
leaq 0x2(%r14), %rdi
callq 0x5370
movq %rax, %rbx
movb $0x5f, (%rax)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10e9b(%rip), %rsi     # 0x19239
leaq 0x10ed3(%rip), %rdx     # 0x19278
leaq 0x8(%rsp), %rdi
callq 0x8496
leal -0x1(%r14), %ebp
cmpl $0x3, %r14d
jl 0x8400
movl %ebp, %r12d
movl $0x1, %r13d
callq 0x50b0
cltq
imulq $-0x7df7df7d, %rax, %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 %eax, %ecx
movslq %ecx, %rax
movq 0x8(%rsp), %rcx
movb (%rcx,%rax), %al
movb %al, (%rbx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x83c2
movslq %ebp, %rax
movb $0x5f, (%rbx,%rax)
movb $0x0, (%rbx,%r14)
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x5120
movq %rbx, %rdx
addq %rax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8496
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8450
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
jmp 0x8477
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x848e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testq %rdi, %rdi
je 0x9123
movq %rdi, %r14
callq 0x5200
movq %rax, %r12
subl %ebx, %r12d
leal 0x1(%r12), %eax
shlq $0x2, %rax
cmpl $-0x1, %r12d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r15
movslq %ebx, %rax
leaq (%r14,%rax,4), %rsi
movslq %r12d, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x50a0
leaq (%r15,%rbx,4), %r14
jmp 0x9144
movl $0x4, %edi
callq 0x5040
movq %rax, %r14
movslq %ebx, %rsi
shlq $0x2, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x50a0
movq %r14, %r15
movl $0x0, (%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
testq %rdi, %rdi
cmovnel %edx, %r12d
leal 0x1(%r12), %eax
shlq $0x2, %rax
cmpl $-0x1, %r12d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r15
movslq %ebx, %rax
leaq (%r14,%rax,4), %rsi
movslq %r12d, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x50a0
movl $0x0, (%r15,%rbx,4)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x9236
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5200
movq %rax, %r14
movq %rax, %r15
shlq $0x20, %r15
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %r15, %rax
movq %rax, %rcx
sarq $0x1e, %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
testl %r14d, %r14d
js 0x9224
incl %r14d
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
leal -0x61(%rdx), %esi
leal -0x20(%rdx), %edi
cmpl $0x1a, %esi
cmovael %edx, %edi
movl %edi, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x920a
sarq $0x1e, %r15
movl $0x0, (%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x92cb
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leal 0x1(%rbx), %r15d
leaq (,%r15,4), %rax
cmpl $-0x1, %edx
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
testl %ebx, %ebx
js 0x92b6
movslq %ebp, %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
leal -0x41(%rsi), %edi
movl %esi, %r8d
orl $0x20, %r8d
cmpl $0x1a, %edi
cmovael %esi, %r8d
movl %r8d, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x9296
movslq %ebx, %rcx
movl $0x0, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl $0x0, %r15d
testq %rdi, %rdi
je 0x92f6
movq %r14, %rdi
callq 0x5200
movq %rax, %r15
testq %rbx, %rbx
je 0x9306
movq %rbx, %rdi
callq 0x5200
movq %rax, %r12
addl %r15d, %r12d
movslq %r12d, %r13
leaq 0x4(,%r13,4), %rax
cmpl $-0x1, %r13d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
testq %r14, %r14
je 0x933b
movq %r12, %rdi
movq %r14, %rsi
callq 0x54a0
testq %rbx, %rbx
je 0x934f
movslq %r15d, %rax
leaq (%r12,%rax,4), %rdi
movq %rbx, %rsi
callq 0x54a0
movl $0x0, (%r12,%r13,4)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
je 0x93a9
movq %r14, %rdi
callq 0x5200
movq %rax, %rcx
shlq $0x20, %rcx
movabsq $0x200000000, %rdx      # imm = 0x200000000
addq %rcx, %rdx
sarq $0x1e, %rdx
cmpl $-0x2, %eax
movq $-0x1, %rdi
cmovgeq %rdx, %rdi
movslq %eax, %r15
jmp 0x93b1
movl $0x8, %edi
xorl %r15d, %r15d
callq 0x5040
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x50a0
movl %ebx, (%r12,%r15,4)
movl $0x0, 0x4(%r12,%r15,4)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x94c7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x92ce
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x94bd
callq 0x5360
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x9504
movl (%rdi), %eax
testl %eax, %eax
je 0x9507
addq $0x4, %rdi
xorl %edx, %edx
leal (,%rdx,8), %ecx
subl %edx, %ecx
xorl %eax, %ecx
movl (%rdi), %eax
addq $0x4, %rdi
movl %ecx, %edx
testl %eax, %eax
jne 0x94eb
jmp 0x9509
xorl %eax, %eax
retq
xorl %ecx, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x956d
movq %rdi, %r14
callq 0x5120
movq %rax, %rbx
shlq $0x20, %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rax, %rcx
sarq $0x1e, %rcx
cmpl $-0x1, %ebx
movq $-0x1, %rdi
cmovgeq %rcx, %rdi
callq 0x5040
testl %ebx, %ebx
jle 0x9579
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
movsbl (%r14,%rdx), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x955b
jmp 0x9579
movl $0x4, %edi
callq 0x5040
xorl %ebx, %ebx
movslq %ebx, %rcx
movl $0x0, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x95a4
movq %rbx, %rdi
callq 0x5200
movq %rax, %r14
jmp 0x95a7
xorl %r14d, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x5040
testl %r14d, %r14d
jle 0x95cd
movl %r14d, %ecx
xorl %edx, %edx
movb (%rbx,%rdx,4), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x95bd
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1bcde(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movb %dl, 0x30(%rdi)
testq %rsi, %rsi
je 0x969f
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5030
cmpq $-0x1, %rax
je 0x969f
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x52f0
movq %r14, %rdi
callq 0x5030
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52f0
movl 0x1c(%rbx), %r14d
movl $0x10000, %ebp          # imm = 0x10000
cmpl %ebp, %r14d
cmovll %r14d, %ebp
movl %ebp, 0x18(%rbx)
movl $0x7fffffff, 0x14(%rbx) # imm = 0x7FFFFFFF
testl %r14d, %r14d
movl $0x400, %eax            # imm = 0x400
cmovgl %ebp, %eax
jmp 0x96b8
movq $0x0, 0x14(%rbx)
movl $0x0, 0x1c(%rbx)
movl $0x400, %eax            # imm = 0x400
xorl %ebp, %ebp
xorl %r14d, %r14d
movl %eax, 0x10(%rbx)
movl %eax, %edi
callq 0x5040
movq %rax, 0x8(%rbx)
testl %r14d, %r14d
jle 0x96df
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rax)
movl 0x18(%rbx), %ebp
movl 0x1c(%rbx), %r14d
jmp 0x96e6
movl $0x0, 0x20(%rbx)
cmpl %r14d, %ebp
jne 0x970c
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x970c
callq 0x5030
cmpq $-0x1, %rax
je 0x970c
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x1bbd9(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdi)
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x28(%rsi)
movb 0x30(%rsi), %al
movb %al, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1bb94(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movslq %edx, %r15
movq %r15, %rdi
callq 0x5040
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x51e0
xorl %eax, %eax
movl %eax, 0x14(%r14)
movl %r15d, 0x18(%r14)
movl %r15d, 0x10(%r14)
movl %r15d, 0x1c(%r14)
movl %eax, 0x20(%r14)
movq $0x0, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x18(%rdi), %eax
jl 0x982d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl 0x1c(%rbx), %eax
jge 0x9846
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0x38(%rcx)
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x20(%rbx)
cltq
movzbl (%rcx,%rax), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x28(%rbx), %rdi
movl $0x10000, %ebp          # imm = 0x10000
testq %rdi, %rdi
je 0x983d
callq 0x5030
cmpq $-0x1, %rax
jne 0x983d
movq %rbx, %rdi
callq 0x986e
testl %eax, %eax
jne 0x982a
jmp 0x983d
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movl 0x18(%rdi), %ebp
subl %ebp, %eax
je 0x9889
movq 0x8(%rbx), %r14
jmp 0x98c5
movslq %ebp, %r12
movq %r12, %rdi
addq %r12, %rdi
movl %edi, 0x10(%rbx)
callq 0x5040
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x51e0
testq %r15, %r15
je 0x98bf
movq %r15, %rdi
callq 0x5360
movl 0x18(%rbx), %ebp
movq %r14, 0x8(%rbx)
movl %ebp, %eax
movslq %ebp, %rdi
addq %r14, %rdi
movslq %eax, %rdx
movq 0x28(%rbx), %rcx
movl $0x1, %esi
callq 0x53e0
testl %eax, %eax
jle 0x98ed
movl 0x18(%rbx), %ecx
addl %eax, %ecx
movl %ecx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
jmp 0x98ef
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movl %edx, %eax
subl %esi, %eax
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
xorl %r12d, %r12d
cmpl %ebp, %eax
jge 0x999f
xorl %r12d, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, (%r14,%r12,4)
incq %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl %ebp, %eax
jl 0x9982
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x38(%rax)
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x915a
movq %rax, %rbx
movq %r14, %rdi
callq 0x5360
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1c(%rdi), %ecx
cmpl %esi, %ecx
setg %al
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
sete %dl
orb %al, %dl
jne 0x9a22
callq 0x5030
cmpq $-0x1, %rax
setne %al
movl 0x1c(%rbx), %ecx
cmpl %ebp, %ecx
setg %dl
orb %al, %dl
jne 0x9a22
movq %rbx, %rdi
callq 0x986e
movl 0x1c(%rbx), %ecx
testl %eax, %eax
je 0x9a22
cmpl %ebp, %ecx
jle 0x9a0f
testl %ebp, %ebp
js 0x9a7f
cmpl %ebp, %ecx
jl 0x9a7f
movl 0x14(%rbx), %eax
movl %ebp, %r14d
subl %eax, %r14d
jl 0x9a3e
movl 0x18(%rbx), %edx
addl %eax, %edx
cmpl %ebp, %edx
jg 0x9a76
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x9a71
movl %ebp, %esi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x52f0
movslq 0x10(%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rcx
movl $0x1, %esi
callq 0x53e0
movl %eax, 0x18(%rbx)
movl %ebp, 0x14(%rbx)
jmp 0x9a76
subl %eax, %ecx
movl %ecx, %r14d
movl %r14d, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfb7f(%rip), %rdi      # 0x19605
movl %ebp, %esi
xorl %eax, %eax
callq 0x5070
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: UTF8Buffer::Read()
int UTF8Buffer::Read() {
	int ch;
	do {
		ch = Buffer::Read();
		// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
	} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EoF));
	if (ch < 128 || ch == EoF) {
		// nothing to do, first 127 chars are the same in ascii and utf8
		// 0xxxxxxx or end of file character
	} else if ((ch & 0xF0) == 0xF0) {
		// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
		int c1 = ch & 0x07; ch = Buffer::Read();
		int c2 = ch & 0x3F; ch = Buffer::Read();
		int c3 = ch & 0x3F; ch = Buffer::Read();
		int c4 = ch & 0x3F;
		ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
	} else if ((ch & 0xE0) == 0xE0) {
		// 1110xxxx 10xxxxxx 10xxxxxx
		int c1 = ch & 0x0F; ch = Buffer::Read();
		int c2 = ch & 0x3F; ch = Buffer::Read();
		int c3 = ch & 0x3F;
		ch = (((c1 << 6) | c2) << 6) | c3;
	} else if ((ch & 0xC0) == 0xC0) {
		// 110xxxxx 10xxxxxx
		int c1 = ch & 0x1F; ch = Buffer::Read();
		int c2 = ch & 0x3F;
		ch = (c1 << 6) | c2;
	}
	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r14, %rdi
callq 0x97fa
movl %eax, %ebx
cmpl $0x80, %eax
jb 0x9b68
movl %ebx, %eax
andl $0xc0, %eax
cmpl $0x10000, %ebx          # imm = 0x10000
je 0x9acf
cmpl $0xc0, %eax
jne 0x9aa4
movl $0x10000, %ebp          # imm = 0x10000
cmpl $0x10000, %ebx          # imm = 0x10000
je 0x9b6a
movl %ebx, %ecx
notl %ecx
testb $-0x10, %cl
jne 0x9b25
movq %r14, %rdi
callq 0x97fa
movl %eax, %r15d
andl $0x3f, %r15d
movq %r14, %rdi
callq 0x97fa
movl %eax, %ebp
movq %r14, %rdi
callq 0x97fa
andl $0x3f, %eax
andl $0x7, %ebx
shll $0x6, %ebx
orl %r15d, %ebx
shll $0xc, %ebx
andl $0x3f, %ebp
shll $0x6, %ebp
orl %ebx, %ebp
orl %eax, %ebp
jmp 0x9b6a
testb $-0x20, %cl
jne 0x9b4c
movq %r14, %rdi
callq 0x97fa
movl %eax, %ebp
andl $0x3f, %ebp
movq %r14, %rdi
callq 0x97fa
andl $0x3f, %eax
andl $0xf, %ebx
shll $0x6, %ebx
orl %ebp, %ebx
jmp 0x9b63
movl %ebx, %ebp
cmpl $0xc0, %eax
jne 0x9b6a
movq %r14, %rdi
callq 0x97fa
andl $0x3f, %eax
andl $0x1f, %ebx
shll $0x6, %ebx
orl %eax, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1aeb5(%rip), %rax     # 0x253d8
movq %rax, 0x38(%rdi)
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x40(%rbx)
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5170
leaq 0x1aebd(%rip), %rax     # 0x25408
movq %rax, 0x48(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x50(%rbx)
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5170
movq %r14, %rdi
callq 0x958b
movq %rax, %r15
leaq 0xf0b6(%rip), %rsi      # 0x19634
movq %rax, %rdi
callq 0x5320
testq %rax, %rax
je 0xa5cb
movq %rax, %r12
movq %r15, %rdi
callq 0x5360
movl $0x38, %edi
callq 0x5290
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9624
movq %r15, 0x98(%rbx)
movq %rbx, %rdi
callq 0x9c7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf065(%rip), %rdi      # 0x19637
movq %r14, %rsi
xorl %eax, %eax
callq 0x5070
movl $0x1, %edi
callq 0x5340
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x52a0
jmp 0xa600
movq %rax, %r14
jmp 0xa609
movq %rax, %r14
leaq 0x48(%rbx), %rdi
callq 0xb7b0
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xb80a
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa708
movq 0x4000000(%rdi), %r14
callq 0x5330
movq %r14, (%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0xa6f1
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xa716
callq 0x5360
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0xa728
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x48(%rbx), %rdi
callq 0xb7b0
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb80a
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl 0x94(%rdi), %eax
testl %eax, %eax
jle 0xa766
movzbl 0x20(%rbx), %ecx
movl %ecx, 0x80(%rbx)
decl %eax
movl %eax, 0x94(%rbx)
jmp 0xa7d9
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, 0x84(%rbx)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x80(%rbx)
incl 0x90(%rbx)
incl 0x88(%rbx)
cmpl $0xd, %eax
jne 0xa7c1
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0xa, %eax
jne 0xa7b7
movl 0x80(%rbx), %eax
jmp 0xa7c1
movzbl 0x20(%rbx), %eax
movl %eax, 0x80(%rbx)
movzbl 0x20(%rbx), %ecx
cmpl %ecx, %eax
jne 0xa7d9
incl 0x8c(%rbx)
movl $0x0, 0x90(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq 0x18(%rdi), %rcx
jb 0xa7fa
movq %rbx, %rdi
callq 0xab0e
movq 0x10(%rbx), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x6c(%rdi), %r14
movslq 0x68(%rdi), %rax
cmpl %eax, %r14d
jl 0xa86d
leal (%rax,%rax), %ecx
movl %ecx, 0x68(%rbx)
movq %rax, %rcx
shlq $0x3, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movq %rax, %r15
movq 0x60(%rbx), %r12
shlq $0x2, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x51e0
testq %r12, %r12
je 0xa869
movq %r12, %rdi
callq 0x5360
movq %r15, 0x60(%rbx)
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jne 0xa886
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x60(%rbx), %rcx
movslq 0x6c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x6c(%rbx)
movl %eax, (%rcx,%rdx,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa744
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x84(%rdi), %ebp
movl 0x88(%rdi), %r14d
movq 0x8c(%rdi), %xmm0
movdqa %xmm0, (%rsp)
callq 0xa744
cmpl $0x2f, 0x80(%rbx)
jne 0xa91a
movq %rbx, %rdi
callq 0xa744
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
je 0xa945
cmpl $0xa, %eax
jne 0xa8dd
movl 0x8c(%rbx), %eax
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
subl %ecx, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0xa744
movb $0x1, %al
jmp 0xa947
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa744
movdqa (%rsp), %xmm0
movq %xmm0, 0x8c(%rbx)
movl %r14d, 0x88(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x84(%rdi), %ebp
movl 0x88(%rdi), %r14d
movq 0x8c(%rdi), %xmm0
movdqa %xmm0, (%rsp)
callq 0xa744
cmpl $0x2a, 0x80(%rbx)
jne 0xa9f8
movl $0x1, %ebp
movq %rbx, %rdi
callq 0xa744
movl 0x80(%rbx), %eax
cmpl $0x28, %eax
je 0xa9b3
cmpl $0x2a, %eax
jne 0xa9c8
movq %rbx, %rdi
callq 0xa744
cmpl $0x29, 0x80(%rbx)
jne 0xa990
jmp 0xa9d1
movq %rbx, %rdi
callq 0xa744
cmpl $0x2a, 0x80(%rbx)
jne 0xa990
incl %ebp
jmp 0xa988
cmpl $0x10000, %eax          # imm = 0x10000
jne 0xa988
jmp 0xaa23
decl %ebp
jne 0xa988
movl 0x8c(%rbx), %eax
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
subl %ecx, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0xa744
movb $0x1, %al
jmp 0xaa25
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa744
movdqa (%rsp), %xmm0
movq %xmm0, 0x8c(%rbx)
movl %r14d, 0x88(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::CreateHeapBlock()
void Scanner::CreateHeapBlock() {
	void* newHeap;
	char* cur = (char*) firstHeap;

	while(((char*) tokens < cur) || ((char*) tokens > (cur + COCO_HEAP_BLOCK_SIZE))) {
		cur = *((char**) (cur + COCO_HEAP_BLOCK_SIZE));
		free(firstHeap);
		firstHeap = cur;
	}

	// COCO_HEAP_BLOCK_SIZE byte heap + pointer to next heap block
	newHeap = malloc(COCO_HEAP_BLOCK_SIZE + sizeof(void*));
	*heapEnd = newHeap;
	heapEnd = (void**) (((char*) newHeap) + COCO_HEAP_BLOCK_SIZE);
	*heapEnd = 0;
	heap = newHeap;
	heapTop = heap;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x70(%rbx), %rax
cmpq %rdi, %rax
setb %cl
leaq 0x4000000(%rdi), %rdx
cmpq %rdx, %rax
seta %al
orb %cl, %al
cmpb $0x1, %al
jne 0xab68
movl $0x4000000, %r14d       # imm = 0x4000000
movq 0x4000000(%rdi), %r15
callq 0x5330
movq %r15, (%rbx)
movq 0x70(%rbx), %rax
cmpq %r15, %rax
setb %cl
movq %r15, %rdx
addq %r14, %rdx
cmpq %rdx, %rax
seta %al
orb %cl, %al
movq %r15, %rdi
jne 0xab3c
movl $0x4000008, %edi        # imm = 0x4000008
callq 0x5370
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x4000000(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq $0x0, 0x4000000(%rax)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::AppendVal(Token*)
void Scanner::AppendVal(Token *t) {
	int reqMem = (tlen + 1) * sizeof(wchar_t);
	if (((char*) heapTop + reqMem) >= (char*) heapEnd) {
		if (reqMem > COCO_HEAP_BLOCK_SIZE) {
			printf("--- Too long token value\n");
			exit(1);
		}
		CreateHeapBlock();
	}
	t->val = (wchar_t*) heapTop;
	heapTop = (void*) ((char*) heapTop + reqMem);

	wcsncpy(t->val, tval, tlen);
	t->val[tlen] = L'\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x6c(%rdi), %eax
leal 0x4(,%rax,4), %ecx
movq 0x10(%rdi), %rdi
movslq %ecx, %r15
leaq (%rdi,%r15), %rdx
cmpq 0x18(%rbx), %rdx
jb 0xabdb
cmpl $0x4000001, %ecx        # imm = 0x4000001
jge 0xac07
movq %rbx, %rdi
callq 0xab0e
movq 0x10(%rbx), %rdi
movl 0x6c(%rbx), %eax
movq %rdi, 0x18(%r14)
addq %rdi, %r15
movq %r15, 0x10(%rbx)
movq 0x60(%rbx), %rsi
movslq %eax, %rdx
callq 0x50a0
movq 0x18(%r14), %rax
movslq 0x6c(%rbx), %rcx
movl $0x0, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xea6c(%rip), %rdi      # 0x1967a
callq 0x5400
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::SetScannerBehindT()
void Scanner::SetScannerBehindT() {
	buffer->SetPos(t->pos);
	NextCh();
	line = t->line; col = t->col; charPos = t->charPos;
	for (int i = 0; i < tlen; i++) NextCh();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0x98(%rdi), %rdi
movl 0x4(%rax), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa744
movq 0x58(%rbx), %rax
movq 0xc(%rax), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x8c(%rbx)
movl 0x8(%rax), %eax
movl %eax, 0x88(%rbx)
cmpl $0x0, 0x6c(%rbx)
jle 0xb70a
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xa744
incl %ebp
cmpl 0x6c(%rbx), %ebp
jl 0xb6fb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Peek()
Token* Scanner::Peek() {
	do {
		if (pt->next == NULL) {
			pt->next = NextToken();
		}
		pt = pt->next;
	} while (pt->kind > maxT); // skip pragmas

	return pt;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xb757
movq %rbx, %rdi
callq 0xac1e
movq 0x78(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq %rax, 0x78(%rbx)
movl (%rax), %ecx
cmpl 0x2c(%rbx), %ecx
jg 0xb73e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::~Buffer()
Buffer::~Buffer() {
	Close(); 
	if (buf != NULL) {
		delete [] buf;
		buf = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x19b97(%rip), %rax     # 0x25310
movq %rax, (%rdi)
cmpb $0x0, 0x30(%rdi)
jne 0xb798
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xb798
callq 0x5280
movq $0x0, 0x28(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb7ae
callq 0x5360
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Scanner.h
// Function: KeywordMap::~KeywordMap()
virtual ~KeywordMap() {
		for (int i = 0; i < 128; ++i) {
			Elem *e = tab[i];
			while (e != NULL) {
				Elem *next = e->next;
				delete e;
				e = next;
			}
		}
		delete [] tab;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x19c49(%rip), %rax     # 0x25408
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xb7e4
movq (%rdi), %rax
movq 0x18(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xb7d2
incq %r14
cmpq $0x80, %r14
jne 0xb7c5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb803
popq %rbx
popq %r14
popq %r15
jmp 0x5360
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Get()
void Parser::Get() {
	for (;;) {
		t = la;
		la = scanner->Scan();
		if (la->kind <= maxT) { ++errDist; break; }

		if (dummyToken != t) {
			dummyToken->kind = t->kind;
			dummyToken->pos = t->pos;
			dummyToken->col = t->col;
			dummyToken->line = t->line;
			dummyToken->next = NULL;
			coco_string_delete(dummyToken->val);
			dummyToken->val = coco_string_create(t->val);
			t = dummyToken;
		}
		la = t;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x30(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0xb712
movq %rax, 0x30(%rbx)
movl (%rax), %eax
cmpl (%rbx), %eax
jle 0xbe2e
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rcx
cmpq %rcx, %rdi
je 0xbe20
movq (%rcx), %rax
movq %rax, (%rdi)
movq 0xc(%rcx), %rax
movq %rax, 0xc(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x18, %rdi
callq 0x93f6
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x90c4
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x30(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x18(%rbx), %rdi
jmp 0xbdd0
incl 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::ExpectWeak(int, int)
void Parser::ExpectWeak(int n, int follow) {
	if (la->kind == n) Get();
	else {
		SynErr(n);
		while (!StartOf(follow)) Get();
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpl %esi, (%rax)
jne 0xbe61
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbdc0
movl %edx, %ebp
movq %rbx, %rdi
callq 0xba20
movslq %ebp, %rax
movq 0x30(%rbx), %rcx
movslq (%rcx), %rcx
imulq $0x34, %rax, %rax
leaq 0xdb30(%rip), %r14      # 0x199b0
addq %rax, %r14
cmpb $0x0, (%rcx,%r14)
jne 0xbea0
movq %rbx, %rdi
callq 0xbdc0
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x1, (%rax,%r14)
jne 0xbe8a
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::WeakSeparator(int, int, int)
bool Parser::WeakSeparator(int n, int syFol, int repFol) {
	if (la->kind == n) {Get(); return true;}
	else if (StartOf(repFol)) {return false;}
	else {
		SynErr(n);
		while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
			Get();
		}
		return StartOf(syFol);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpl %esi, %eax
jne 0xbee5
movq %rbx, %rdi
callq 0xbdc0
movb $0x1, %bpl
jmp 0xbf4a
movslq %ecx, %rcx
imulq $0x34, %rcx, %r14
leaq 0xdabd(%rip), %r15      # 0x199b0
addq %r15, %r14
cmpb $0x0, (%rax,%r14)
je 0xbf01
xorl %ebp, %ebp
jmp 0xbf4a
movl %edx, %ebp
movq %rbx, %rdi
callq 0xba20
movslq %ebp, %rcx
movq 0x30(%rbx), %rax
movslq (%rax), %rax
imulq $0x34, %rcx, %r12
addq %r15, %r12
movb $0x1, %bpl
cmpb $0x0, (%rax,%r12)
jne 0xbf4a
cmpb $0x0, (%rax,%r14)
jne 0xbefd
cmpb $0x0, (%rax,%r15)
jne 0xbefd
movq %rbx, %rdi
callq 0xbdc0
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x1, (%rax,%r12)
jne 0xbf26
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::SourceCode(LEAF::AST::NODEU*&)
bool Parser::StartOf(int s) {
	const bool T = true;
	const bool x = false;

	static bool set[11][52] = {
		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,x,x, T,x,x,x, x,T,x,T, x,T,T,T, x,T,T,T, x,T,T,x, T,T,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,T,T, T,x,T,T, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, T,T,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x},
		{T,T,T,x, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, x,T,T,x, T,T,T,T, T,T,T,T, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,T,x,x},
		{x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x}
	};



	return set[s][la->kind];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movslq (%rax), %rax
leaq 0xda10(%rip), %r12      # 0x199b0
cmpb $0x1, 0x34(%rax,%r12)
jne 0xbfd7
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xbfe4
movq (%rbx), %rdi
movq (%rsp), %rsi
callq 0x8d18
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x0, 0x34(%rax,%r12)
jne 0xbfb1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::ActParams(LEAF::AST::NODEU*&, bool)
void Parser::ActParams(ASTU&f_node,bool ifc) {
		Obj * obj = get_obj(f_node);  int n = 0; f_node = func_call(f_node,ifc);
		Expect(15 /* "(" */);
		if (StartOf(2)) {
			ASTU s_2;
			Expr(s_2);
			n++; block_add(f_node,s_2); 
			while (la->kind == 25 /* "," */) {
				Get();
				ASTU s_2;
				Expr(s_2);
				n++; block_add(f_node,s_2); 
			}
		}
		Expect(16 /* ")" */);
		if(n!=obj->nPars){
		cout<<";la funcion recibe n parametros: "<<obj->nPars<<" actual: "<<n<<  endl;
		exit(1);
		}
		
		unwrap_call_function(get_obj(f_node));
		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x8d62
movq %rax, %r14
movq (%r15), %rdi
movl %ebp, %esi
callq 0x8d61
movq %rax, (%r15)
movq %rbx, %rdi
movl $0xf, %esi
callq 0xbe34
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xcdb9(%rip), %rcx      # 0x199b0
xorl %ebp, %ebp
cmpb $0x1, 0x68(%rax,%rcx)
jne 0xcc57
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe47c
movq (%r15), %rdi
movq (%r12), %rsi
callq 0x8d18
movq 0x30(%rbx), %rax
movl $0x1, %ebp
cmpl $0x19, (%rax)
jne 0xcc57
movq %rsp, %r12
movq %rbx, %rdi
callq 0xbdc0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe47c
incl %ebp
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x8d18
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
je 0xcc2d
movq %rbx, %rdi
movl $0x10, %esi
callq 0xbe34
cmpl 0x38(%r14), %ebp
jne 0xcc89
movq (%r15), %rdi
callq 0x8d62
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xefb6
movq 0x19348(%rip), %rdi     # 0x25fd8
leaq 0xcff6(%rip), %rsi      # 0x19c8d
callq 0x5270
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x5460
leaq 0xd000(%rip), %rsi      # 0x19caf
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
movl %ebp, %esi
callq 0x5460
movq %rax, %rdi
callq 0x5130
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::StatementBLock(LEAF::AST::NODEU*&)
void Parser::StatementBLock(ASTU&b_node) {
		
		Expect(9 /* "{" */);
		while (StartOf(1)) {
			ASTU stat;
			Statement(stat);
			block_add(b_node,stat); 
		}
		Expect(10 /* "}" */);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x9, %esi
callq 0xbe34
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xc6ba(%rip), %r12      # 0x199b0
cmpb $0x1, 0x34(%rax,%r12)
jne 0xd327
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbfe4
movq (%r14), %rdi
movq (%rsp), %rsi
callq 0x8d18
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x0, 0x34(%rax,%r12)
jne 0xd301
movq %rbx, %rdi
movl $0xa, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbe34
nop