LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%r12)
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2190
cmpl $0x0, (%r12)
je 0x3af6
leaq 0x2(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2612
jmp 0x3b11
movq %rax, %r15
leaq 0x3(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2612
movq %r15, %rdi
callq 0x2220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/main.cpp
// Function: label_of_function[abi:cxx11](Obj*)
string *label_of_function(Obj *f)
{

    string *label = new string();

    label->append(f->name->c_str());
    label->append("_");

    Obj *last = f->locals;

    while (last != NULL)
    {
        label->append("@");
        Struct *last_type = last->type;
        while (last_type->kind == Struct::Pointer || last_type->kind == Struct::Arr || last_type->kind == Struct::Func)
        {
            label->append(to_string(last_type->kind));
            label->append("_");
            last_type = last_type->elemType;
        }

        label->append(to_string(last_type->kind));
        label->append("");
        label->append("_");
        last = last->next;
    }

    Struct *last_type = f->type->elemType;
    label->append("#");
    while (last_type->kind == Struct::Pointer || last_type->kind == Struct::Arr || last_type->kind == Struct::Func)
    {
        label->append(to_string(last_type->kind));
        label->append("_");
        last_type = last_type->elemType;
    }
    label->append(to_string(last_type->kind));
    label->append(":");

    return label;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5460
leaq 0xf639(%rip), %r15      # 0x162b7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5460
movq %r14, (%rsp)
leaq 0x40(%r14), %r13
leaq 0x8(%rsp), %r12
movl $0x1220, %r14d          # imm = 0x1220
movq (%r13), %r13
testq %r13, %r13
je 0x6d2b
leaq 0xf380(%rip), %rsi      # 0x16030
movq %r13, %rbp
movq %rbx, %rdi
callq 0x5460
movq 0x18(%rbp), %rbp
movl 0x10(%rbp), %esi
cmpl $0xc, %esi
ja 0x6ced
btl %esi, %r14d
jae 0x6ced
movq %r12, %rdi
callq 0x70e9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5470
movq %r12, %rdi
callq 0x5488
movq %r15, %rsi
jmp 0x6cb3
movq %r12, %rdi
callq 0x70e9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5470
movq %r12, %rdi
callq 0x5488
movq %rbx, %rdi
leaq 0x11091(%rip), %rsi     # 0x17da3
callq 0x5460
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5460
addq $0x20, %r13
jmp 0x6c9c
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r12
leaq 0xf2f4(%rip), %rsi      # 0x16032
movq %rbx, %rdi
callq 0x5460
movl $0x1220, %ebp           # imm = 0x1220
leaq 0x8(%rsp), %r14
leaq 0xf560(%rip), %r15      # 0x162b7
movl 0x10(%r12), %esi
cmpl $0xc, %esi
ja 0x6d93
btl %esi, %ebp
jae 0x6d93
movq %r14, %rdi
callq 0x70e9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5470
movq %r14, %rdi
callq 0x5488
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5460
movq 0x18(%r12), %r12
jmp 0x6d57
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x70e9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5470
leaq 0x8(%rsp), %rdi
callq 0x5488
leaq 0xf278(%rip), %rsi      # 0x16034
movq %rbx, %rdi
callq 0x5460
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ddc
jmp 0x6ddc
jmp 0x6ddc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x7428
leaq 0x1c87c(%rip), %rax     # 0x23cd8
movq %rax, (%r15)
movq %r14, 0x28(%r15)
movq %rbx, 0x30(%r15)
movl %ebp, 0x38(%r15)
movq 0x8(%r14), %rax
movq 0x18(%rax), %rax
movq 0x8(%r15), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movslq %edi, %r14
leaq 0x2(%r14), %rdi
callq 0x5330
movq %rax, %rbx
movb $0x5f, (%rax)
leaq 0xe9f0(%rip), %rsi      # 0x16279
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x70ae
leaq -0x1(%r14), %r15
pushq $0x1
popq %r12
pushq $0x3f
popq %rbp
cmpq %r15, %r12
jge 0x78c4
callq 0x50a0
cltd
idivl %ebp
movslq %edx, %rax
movq 0x10(%rsp), %rcx
movb (%rcx,%rax), %al
movb %al, (%rbx,%r12)
incq %r12
jmp 0x78a3
movb $0x5f, (%rbx,%r15)
movb $0x0, (%rbx,%r14)
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x70ae
leaq 0x10(%rsp), %rdi
callq 0x5488
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0x7916
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
je 0x84a8
movq %r14, %rdi
callq 0x51e0
movq %rax, %rdx
subl %ebx, %edx
jmp 0x84aa
xorl %edx, %edx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84bb
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %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 0x5090
andl $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_O2/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 0x8589
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x51e0
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
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movslq %r14d, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jg 0x857a
movl (%rbx,%rdx,4), %esi
leal -0x61(%rsi), %edi
leal -0x20(%rsi), %r8d
cmpl $0x1a, %edi
cmovael %esi, %r8d
movl %r8d, (%rax,%rdx,4)
incq %rdx
jmp 0x855b
sarq $0x1e, %r15
andl $0x0, (%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x860b
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leal 0x1(%r14), %eax
shlq $0x2, %rax
cmpl $-0x1, %edx
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x5040
movslq %r14d, %rcx
movslq %ebp, %rdx
leaq (%rbx,%rdx,4), %rdx
xorl %esi, %esi
cmpq %rcx, %rsi
jg 0x8602
movl (%rdx,%rsi,4), %edi
leal -0x41(%rdi), %r8d
movl %edi, %r9d
orl $0x20, %r9d
cmpl $0x1a, %r8d
cmovael %edi, %r9d
movl %r9d, (%rax,%rsi,4)
incq %rsi
jmp 0x85de
andl $0x0, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8636
movq %r14, %rdi
callq 0x51e0
movq %rax, %r15
testq %rbx, %rbx
je 0x8646
movq %rbx, %rdi
callq 0x51e0
movq %rax, %r12
addl %r15d, %r12d
movslq %r12d, %r13
leaq 0x4(,%r13,4), %rax
cmpl $-0x1, %r13d
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
testq %r14, %r14
je 0x8677
movq %r12, %rdi
movq %r14, %rsi
callq 0x5450
testq %rbx, %rbx
je 0x868b
movslq %r15d, %rax
leaq (%r12,%rax,4), %rdi
movq %rbx, %rsi
callq 0x5450
andl $0x0, (%r12,%r13,4)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x86f7
movl %eax, %r15d
leal 0x2(%r15), %eax
shlq $0x2, %rax
cmpl $-0x2, %r15d
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
movslq %r15d, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5090
movl %ebx, (%r12,%r15,4)
andl $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_O2/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 0x87d8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x860e
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x87ce
callq 0x5320
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x880b
xorl %ecx, %ecx
movl (%rdi), %eax
testl %eax, %eax
je 0x8803
imull $0x7, %ecx, %ecx
xorl %eax, %ecx
addq $0x4, %rdi
jmp 0x87f2
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x0, %r14d
testq %rdi, %rdi
je 0x882f
movq %rbx, %rdi
callq 0x5100
movq %rax, %r14
leal 0x1(%r14), %eax
shlq $0x2, %rax
cmpl $-0x1, %r14d
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x5040
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %r15, %rcx
je 0x8866
movsbl (%rbx,%r15), %edx
movl %edx, (%rax,%r15,4)
incq %r15
jmp 0x8853
movslq %r14d, %rcx
andl $0x0, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x86f7
movl %eax, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x5040
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
cmpq %rcx, %rdx
je 0x88ae
movb (%rbx,%rcx,4), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x889c
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x1b927(%rip), %rax     # 0x24228
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movb %dl, 0x30(%rdi)
callq 0x89c0
testb %al, %al
je 0x895f
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x52b0
movq %r14, %rdi
callq 0x5030
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52b0
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 0x8972
andl $0x0, 0x1c(%rbx)
andq $0x0, 0x14(%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 0x8999
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rax)
movl 0x18(%rbx), %ebp
movl 0x1c(%rbx), %r14d
jmp 0x899d
andl $0x0, 0x20(%rbx)
cmpl %r14d, %ebp
jne 0x89bb
movq %rbx, %rdi
callq 0x89c0
testb %al, %al
je 0x89bb
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b843(%rip), %rax     # 0x24228
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x8(%rsi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x28(%rsi)
movb 0x30(%rsi), %al
movb %al, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b7fe(%rip), %rax     # 0x24228
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 0x51c0
andl $0x0, 0x14(%r14)
movl %r15d, 0x18(%r14)
movl %r15d, 0x10(%r14)
movl %r15d, 0x1c(%r14)
andl $0x0, 0x20(%r14)
andq $0x0, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ad5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl 0x1c(%rbx), %eax
jge 0x8aee
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
movl $0x10000, %ebp          # imm = 0x10000
cmpq $0x0, 0x28(%rbx)
je 0x8ae5
movq %rbx, %rdi
callq 0x89c0
testb %al, %al
jne 0x8ae5
movq %rbx, %rdi
callq 0x8b14
testl %eax, %eax
jne 0x8ad2
jmp 0x8ae5
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8b2f
movq 0x8(%rbx), %r14
jmp 0x8b6b
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 0x51c0
testq %r15, %r15
je 0x8b65
movq %r15, %rdi
callq 0x5320
movl 0x18(%rbx), %ebp
movq %r14, 0x8(%rbx)
movl %ebp, %eax
movslq %ebp, %rdi
addq %r14, %rdi
movslq %eax, %rdx
movq 0x28(%rbx), %rcx
pushq $0x1
popq %rsi
callq 0x53a0
testl %eax, %eax
jle 0x8b91
movl 0x18(%rbx), %ecx
addl %eax, %ecx
movl %ecx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
jmp 0x8b93
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movl %edx, %eax
subl %esi, %eax
leaq (,%rax,4), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
xorl %r12d, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl %ebp, %eax
jge 0x8c3a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, (%r14,%r12,4)
incq %r12
jmp 0x8c1b
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x38(%rax)
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x84bb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x870a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
jg 0x8cb6
cmpq $0x0, 0x28(%rbx)
je 0x8cb6
movq %rbx, %rdi
callq 0x89c0
movl 0x1c(%rbx), %ecx
cmpl %ebp, %ecx
setg %dl
orb %al, %dl
jne 0x8cb6
movq %rbx, %rdi
callq 0x8b14
movl 0x1c(%rbx), %ecx
testl %eax, %eax
je 0x8cb6
cmpl %ebp, %ecx
jle 0x8ca3
testl %ebp, %ebp
js 0x8d11
cmpl %ebp, %ecx
jl 0x8d11
movl 0x14(%rbx), %eax
movl %ebp, %r14d
subl %eax, %r14d
jl 0x8cd2
movl 0x18(%rbx), %edx
addl %eax, %edx
cmpl %ebp, %edx
jg 0x8d08
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x8d03
movl %ebp, %esi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x52b0
movslq 0x10(%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rcx
pushq $0x1
popq %rsi
callq 0x53a0
movl %eax, 0x18(%rbx)
movl %ebp, 0x14(%rbx)
jmp 0x8d08
subl %eax, %ecx
movl %ecx, %r14d
movl %r14d, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd8fd(%rip), %rdi      # 0x16615
movl %ebp, %esi
xorl %eax, %eax
callq 0x5060
pushq $0x1
popq %rdi
callq 0x5300
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8aa2
movl %eax, %ebx
cmpl $0x80, %eax
jb 0x8df8
movl %ebx, %eax
andl $0xc0, %eax
cmpl $0x10000, %ebx          # imm = 0x10000
je 0x8d5f
cmpl $0xc0, %eax
jne 0x8d34
movl $0x10000, %ebp          # imm = 0x10000
cmpl $0x10000, %ebx          # imm = 0x10000
je 0x8dfa
movl %ebx, %ecx
notl %ecx
testb $-0x10, %cl
jne 0x8db5
movq %r14, %rdi
callq 0x8aa2
movl %eax, %r15d
andl $0x3f, %r15d
movq %r14, %rdi
callq 0x8aa2
movl %eax, %ebp
movq %r14, %rdi
callq 0x8aa2
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 0x8dfa
testb $-0x20, %cl
jne 0x8ddc
movq %r14, %rdi
callq 0x8aa2
movl %eax, %ebp
andl $0x3f, %ebp
movq %r14, %rdi
callq 0x8aa2
andl $0x3f, %eax
andl $0xf, %ebx
shll $0x6, %ebx
orl %ebp, %ebx
jmp 0x8df3
movl %ebx, %ebp
cmpl $0xc0, %eax
jne 0x8dfa
movq %r14, %rdi
callq 0x8aa2
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_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0xa3d8
leaq 0x48(%r15), %r14
movq %r14, %rdi
callq 0xa404
movq %r12, %rdi
callq 0x8873
movq %rax, 0x8(%rsp)
leaq 0xd317(%rip), %rsi      # 0x16644
movq %rax, %rdi
callq 0x52e0
testq %rax, %rax
je 0x937c
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x88bd
pushq $0x38
popq %rdi
callq 0x5260
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x88f0
movq %r12, 0x98(%r15)
movq %r15, %rdi
callq 0x8e9a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xd2c4(%rip), %rdi      # 0x16647
movq %r12, %rsi
xorl %eax, %eax
callq 0x5060
pushq $0x1
popq %rdi
callq 0x5300
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r12, %rdi
callq 0x5270
jmp 0x93ad
movq %rax, %r15
jmp 0x93b5
movq %rax, %r15
movq %r14, %rdi
callq 0xa430
movq %rbx, %rdi
callq 0xa484
movq %r15, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9473
movq 0x4000000(%rdi), %r14
callq 0x52f0
movq %r14, (%rbx)
movq %r14, %rdi
jmp 0x945a
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x9481
callq 0x5320
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x9493
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x48(%rbx), %rdi
callq 0xa430
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa484
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x94d2
movzbl 0x20(%rbx), %ecx
movl %ecx, 0x80(%rbx)
decl %eax
movl %eax, 0x94(%rbx)
jmp 0x9542
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 0x952d
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0xa, %eax
jne 0x9523
movl 0x80(%rbx), %eax
jmp 0x952d
movzbl 0x20(%rbx), %eax
movl %eax, 0x80(%rbx)
movzbl 0x20(%rbx), %ecx
cmpl %ecx, %eax
jne 0x9542
incl 0x8c(%rbx)
andl $0x0, 0x90(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9562
movq %rbx, %rdi
callq 0x986e
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_O2/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 0x95d1
leal (%rax,%rax), %ecx
movl %ecx, 0x68(%rbx)
movq %rax, %rcx
shlq $0x3, %rcx
testl %eax, %eax
pushq $-0x1
popq %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 0x51c0
testq %r12, %r12
je 0x95cd
movq %r12, %rdi
callq 0x5320
movq %r15, 0x60(%rbx)
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jne 0x95ea
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 0x94b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x94b0
cmpl $0x2f, 0x80(%rbx)
jne 0x967e
movq %rbx, %rdi
callq 0x94b0
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
je 0x96a9
cmpl $0xa, %eax
jne 0x9641
movl 0x8c(%rbx), %eax
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
subl %ecx, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0x94b0
movb $0x1, %al
jmp 0x96ab
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x94b0
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_O2/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 0x94b0
cmpl $0x2a, 0x80(%rbx)
jne 0x975a
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0x94b0
movl 0x80(%rbx), %eax
cmpl $0x28, %eax
je 0x9715
cmpl $0x2a, %eax
jne 0x972a
movq %rbx, %rdi
callq 0x94b0
cmpl $0x29, 0x80(%rbx)
jne 0x96f2
jmp 0x9733
movq %rbx, %rdi
callq 0x94b0
cmpl $0x2a, 0x80(%rbx)
jne 0x96f2
incl %ebp
jmp 0x96ea
cmpl $0x10000, %eax          # imm = 0x10000
jne 0x96ea
jmp 0x9785
decl %ebp
jne 0x96ea
movl 0x8c(%rbx), %eax
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
subl %ecx, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0x94b0
movb $0x1, %al
jmp 0x9787
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x94b0
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_O2/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 %r14
pushq %rbx
pushq %rax
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 0x98a9
movq 0x4000000(%rdi), %r14
callq 0x52f0
movq %r14, (%rbx)
movq %r14, %rdi
jmp 0x9878
movl $0x4000008, %edi        # imm = 0x4000008
callq 0x5330
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x4000000(%rax), %rcx
movq %rcx, 0x18(%rbx)
andq $0x0, 0x4000000(%rax)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x991b
cmpl $0x4000001, %ecx        # imm = 0x4000001
jge 0x9944
movq %rbx, %rdi
callq 0x986e
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 0x5090
movq 0x18(%r14), %rax
movslq 0x6c(%rbx), %rcx
andl $0x0, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcd3f(%rip), %rdi      # 0x1668a
callq 0x53c0
pushq $0x1
popq %rdi
callq 0x5300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x94b0
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)
xorl %ebp, %ebp
cmpl 0x6c(%rbx), %ebp
jge 0xa34c
movq %rbx, %rdi
callq 0x94b0
incl %ebp
jmp 0xa33b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa399
movq %rbx, %rdi
callq 0x9958
movq 0x78(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq %rax, 0x78(%rbx)
movl (%rax), %ecx
cmpl 0x2c(%rbx), %ecx
jg 0xa380
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19e6d(%rip), %rax     # 0x24228
movq %rax, (%rdi)
callq 0x8a82
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa3d6
callq 0x5320
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19ee1(%rip), %rax     # 0x24320
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
cmpq $0x80, %r14
je 0xa46f
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0xa46a
movq (%rdi), %rax
movq 0x18(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
jmp 0xa456
incq %r14
jmp 0xa445
testq %rdi, %rdi
je 0xa47e
popq %rbx
popq %r14
popq %r15
jmp 0x5320
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30(%rdi), %rcx
movq %rcx, 0x28(%rbx)
movq 0x18(%rbx), %rdi
callq 0xa354
movq %rax, 0x30(%rbx)
movl (%rax), %eax
cmpl (%rbx), %eax
jle 0xaa95
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rcx
cmpq %rcx, %rdi
je 0xaa8f
movq (%rcx), %rax
movq %rax, (%rdi)
movq 0xc(%rcx), %rax
movq %rax, 0xc(%rdi)
andq $0x0, 0x20(%rdi)
addq $0x18, %rdi
callq 0x870a
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x8484
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
jmp 0xaa36
incl 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaac7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xaa2e
movl %edx, %ebp
movq %rbx, %rdi
callq 0xa6a4
movslq %ebp, %rax
imulq $0x34, %rax, %rax
leaq 0xbee1(%rip), %r14      # 0x169c0
addq %rax, %r14
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x0, (%rax,%r14)
jne 0xaafa
movq %rbx, %rdi
callq 0xaa2e
jmp 0xaae2
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xab3e
movq %rbx, %rdi
callq 0xaa2e
movb $0x1, %al
jmp 0xab58
movslq %ecx, %rcx
imulq $0x34, %rcx, %r14
leaq 0xbe74(%rip), %r15      # 0x169c0
addq %r15, %r14
cmpb $0x0, (%rax,%r14)
je 0xab61
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebp
movq %rbx, %rdi
callq 0xa6a4
movslq %ebp, %rax
imulq $0x34, %rax, %r12
addq %r15, %r12
movq 0x30(%rbx), %rax
movslq (%rax), %rcx
movb (%rcx,%r12), %al
testb %al, %al
jne 0xab58
cmpb $0x0, (%rcx,%r14)
jne 0xab58
cmpb $0x0, (%rcx,%r15)
jne 0xab58
movq %rbx, %rdi
callq 0xaa2e
jmp 0xab75
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::SourceCode(LEAF::AST::NODEU*&)
void Parser::SourceCode(ASTU&b_node) {
		
		while (StartOf(1)) {
			ASTU stat;
			Statement(stat);
			block_add(b_node,stat);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbddb(%rip), %r12      # 0x169c0
movq %rsp, %r15
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x1, 0x34(%rax,%r12)
jne 0xac10
movq %r14, %rdi
movq %r15, %rsi
callq 0xac1c
movq (%rbx), %rdi
movq (%rsp), %rsi
callq 0x8094
jmp 0xabe8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x80da
movq %rax, %r14
movq (%r15), %rdi
movl %ebp, %esi
callq 0x80d9
movq %rax, (%r15)
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xb2c9(%rip), %rcx      # 0x169c0
xorl %ebp, %ebp
cmpb $0x1, 0x68(%rax,%rcx)
jne 0xb74e
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8fa
movq (%r15), %rdi
movq (%r12), %rsi
callq 0x8094
movq %rsp, %r12
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
jne 0xb74e
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8fa
incl %ebp
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x8094
jmp 0xb722
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
cmpl 0x38(%r14), %ebp
jne 0xb77e
movq (%r15), %rdi
callq 0x80da
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd264
movq 0x1984b(%rip), %rdi     # 0x24fd0
leaq 0xb511(%rip), %rsi      # 0x16c9d
callq 0x5240
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x5410
leaq 0xb51b(%rip), %rsi      # 0x16cbf
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
movl %ebp, %esi
callq 0x5410
movq %rax, %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x9
popq %rsi
callq 0xaa9a
leaq 0xade3(%rip), %r12      # 0x169c0
movq %rsp, %r15
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x1, 0x34(%rax,%r12)
jne 0xbc08
movq %rbx, %rdi
movq %r15, %rsi
callq 0xac1c
movq (%r14), %rdi
movq (%rsp), %rsi
callq 0x8094
jmp 0xbbe0
pushq $0xa
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaa9a
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::TryCatchStatement(LEAF::AST::NODEU*&)
void Parser::TryCatchStatement(ASTU&stat) {
		stat = block_try();
		Expect(22 /* "try" */);
		StatementBLock(stat);
		PartCatchStatement(stat);
		while (la->kind == 23 /* "catch" */) {
			PartCatchStatement(stat);
		}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x82e9
movq %rax, (%rbx)
pushq $0x16
popq %rsi
movq %r14, %rdi
callq 0xaa9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbbc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc20c
movq 0x30(%r14), %rax
cmpl $0x17, (%rax)
je 0xbc46
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDcl(Parser::MetaData*)
void Parser::VarDcl(MetaData * md) {
		if (la->kind == _t_pointer) {
			Get();
			VarDcl(md);
			cout << " puntero a";
			puntero(last(md->type));
			
		} else if (StartOf(6)) {
			VarDirectDcl(md);
		} else SynErr(58);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xbcbe
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc62
movq 0x1933d(%rip), %rdi     # 0x24fd0
leaq 0xb090(%rip), %rsi      # 0x16d2a
callq 0x5240
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xbca3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd364
leaq 0xacfb(%rip), %rcx      # 0x169c0
cmpb $0x1, 0x138(%rax,%rcx)
jne 0xbce1
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc3fc
pushq $0x3a
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa6a4
nop