LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x21(%rbp)
jb 0x10eaa
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x4000000, %rcx        # imm = 0x4000000
cmpq %rcx, %rax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x10eb3
jmp 0x10edb
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x4000000(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x63c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x10e7b
movl $0x4000008, %edi        # imm = 0x4000008
callq 0x6420
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x18(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
addq $0x4000000, %rcx        # imm = 0x4000000
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rcx
movq $0x0, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x6c(%rcx), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
movl %eax, -0x14(%rbp)
movq 0x10(%rcx), %rax
movslq -0x14(%rbp), %rdx
addq %rdx, %rax
cmpq 0x18(%rcx), %rax
jb 0x10f92
cmpl $0x4000000, -0x14(%rbp) # imm = 0x4000000
jle 0x10f89
leaq 0x2367e(%rip), %rdi     # 0x345f6
movb $0x0, %al
callq 0x6070
movl $0x1, %edi
callq 0x63d0
movq -0x20(%rbp), %rdi
callq 0x10e60
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq 0x60(%rax), %rsi
movslq 0x6c(%rax), %rdx
callq 0x60b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x6c(%rcx), %rcx
movl $0x0, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x98(%rax), %rdi
movq 0x58(%rax), %rax
movl 0x4(%rax), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x10830
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x8c(%rax)
movq 0x58(%rax), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x90(%rax)
movq 0x58(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x88(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x6c(%rcx), %eax
jge 0x12493
movq -0x18(%rbp), %rdi
callq 0x10830
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12473
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Scan()
Token* Scanner::Scan() {
	if (tokens->next == NULL) {
		return pt = tokens = NextToken();
	} else {
		pt = tokens = tokens->next;
		return tokens;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x70(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x124da
movq -0x18(%rbp), %rdi
callq 0x10ff0
movq -0x18(%rbp), %rcx
movq %rax, 0x70(%rcx)
movq %rax, 0x78(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x124f6
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x70(%rax)
movq %rcx, 0x78(%rax)
movq 0x70(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1253b
movq -0x10(%rbp), %rdi
callq 0x10ff0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rcx
movq 0x78(%rcx), %rax
movl (%rax), %eax
cmpl 0x2c(%rcx), %eax
jg 0x12514
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x369fd(%rip), %rcx     # 0x49048
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x126b8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x126ab
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x126a1
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x12676
jmp 0x126ad
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12659
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x126d3
movq -0x38(%rbp), %rdi
callq 0x6400
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x18(%rax), %rdi
callq 0x124a0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
movq 0x30(%rcx), %rax
movl (%rax), %eax
cmpl (%rcx), %eax
jg 0x132fd
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x13397
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x13386
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movl (%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, (%rcx)
movq 0x28(%rax), %rcx
movl 0x4(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0x4(%rcx)
movq 0x28(%rax), %rcx
movl 0xc(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0xc(%rcx)
movq 0x28(%rax), %rcx
movl 0x10(%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0x10(%rcx)
movq 0x8(%rax), %rcx
movq $0x0, 0x20(%rcx)
movq 0x8(%rax), %rdi
addq $0x18, %rdi
callq 0xf000
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rdi
callq 0xeb30
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rdx, 0x18(%rcx)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x132c4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x13410
movq -0x18(%rbp), %rdi
callq 0x132b0
jmp 0x1343d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x12be0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x13450
xorb $-0x1, %al
testb $0x1, %al
jne 0x13430
jmp 0x1343b
movq -0x18(%rbp), %rdi
callq 0x132b0
jmp 0x1341c
jmp 0x1343d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x30(%rax), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x134ca
movq -0x28(%rbp), %rdi
callq 0x132b0
movb $0x1, -0x1(%rbp)
jmp 0x13553
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x13450
testb $0x1, %al
jne 0x134dc
jmp 0x134e2
movb $0x0, -0x1(%rbp)
jmp 0x13553
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12be0
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x13450
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1352c
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x13450
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1352c
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x13450
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13537
jmp 0x13542
movq -0x28(%rbp), %rdi
callq 0x132b0
jmp 0x134ee
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x13450
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x13450
testb $0x1, %al
jne 0x135dc
jmp 0x135fb
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13610
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xe1e0
jmp 0x135c8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe2e0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xe290
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0xf, %esi
callq 0x133a0
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x13450
testb $0x1, %al
jne 0x14776
jmp 0x147dc
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x146d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xe1e0
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x19, (%rax)
jne 0x147da
movq -0x40(%rbp), %rdi
callq 0x132b0
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x146d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0xe1e0
jmp 0x1479c
jmp 0x147dc
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0x133a0
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x38(%rcx), %eax
je 0x1484b
movq 0x357d3(%rip), %rdi     # 0x49fd0
leaq 0x20241(%rip), %rsi     # 0x34a45
callq 0x62c0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x64e0
movq %rax, %rdi
leaq 0x20245(%rip), %rsi     # 0x34a67
callq 0x62c0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x64e0
movq %rax, %rdi
movq 0x35774(%rip), %rsi     # 0x49fb0
callq 0x6320
movl $0x1, %edi
callq 0x63d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe2e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x17a60
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x9, %esi
callq 0x133a0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x13450
testb $0x1, %al
jne 0x15066
jmp 0x15085
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13610
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xe1e0
jmp 0x15052
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x133a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xe690
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x16, %esi
callq 0x133a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15030
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15cb0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x17, (%rax)
jne 0x1510b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15cb0
jmp 0x150ef
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
cmpl $0x1, (%rax)
jne 0x15189
movq -0x18(%rbp), %rdi
callq 0x132b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15120
movq 0x34e72(%rip), %rdi     # 0x49fd0
leaq 0x1f96d(%rip), %rsi     # 0x34ad2
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x17c30
jmp 0x151bc
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x13450
testb $0x1, %al
jne 0x1519d
jmp 0x151ac
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15fe0
jmp 0x151ba
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x12be0
jmp 0x151bc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::FuncDcl(Parser::MetaData*)
void Parser::FuncDcl(MetaData * fd) {
		if (la->kind == _t_pointer) {
			Get();
			FuncDcl(fd);
			cout << "; puntero a"; 
			puntero(last(fd->type));
		} else if (StartOf(8)) {
			FuncDirectDcl(fd);
		} else SynErr(61);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
cmpl $0x1, (%rax)
jne 0x15c69
movq -0x18(%rbp), %rdi
callq 0x132b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c00
movq 0x34392(%rip), %rdi     # 0x49fd0
leaq 0x1ee8c(%rip), %rsi     # 0x34ad1
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x17c30
jmp 0x15c9c
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x13450
testb $0x1, %al
jne 0x15c7d
jmp 0x15c8c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x163e0
jmp 0x15c9a
movq -0x18(%rbp), %rdi
movl $0x3d, %esi
callq 0x12be0
jmp 0x15c9c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::PartCatchStatement(LEAF::AST::NODEU*&)
void Parser::PartCatchStatement(ASTU&_try_) {
		ASTU catch_ast; ASTU ex_var; 
		Expect(23 /* "catch" */);
		catch_ast = block_catch(); 
		VarDeclDefCatch(ex_var);
		catch_set_ex_var(catch_ast,ex_var); 
		StatementBLock(catch_ast);
		try_add_catch(_try_,catch_ast); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x17, %esi
callq 0x133a0
callq 0xe740
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x15d20
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe7d0
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15030
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xe700
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDirectDcl(Parser::MetaData*)
void Parser::VarDirectDcl(MetaData * md) {
		string * Name = new string("");; 
		if (la->kind == _name) {
			Get();
			LexString(Name);
			cout <<endl<< "; " << *Name << " es"; 
			md->tmpName=Name;
			
		} else if (la->kind == 15 /* "(" */) {
			Get();
			VarDcl(md);
			Expect(16 /* ")" */);
		} else if (StartOf(7)) {
			cout <<endl<< "; noname " << " es";  
		} else SynErr(59);
		while (la->kind == 15 /* "(" */ || la->kind == 26 /* "[" */) {
			VarSuffix(md);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6500
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x1fb43(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x16031
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x30(%rax), %rax
cmpl $0x4, (%rax)
jne 0x160eb
movq -0x50(%rbp), %rdi
callq 0x132b0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17810
movq 0x33f5c(%rip), %rdi     # 0x49fd0
movq 0x33f35(%rip), %rsi     # 0x49fb0
callq 0x6320
movq %rax, %rdi
leaq 0x1ea13(%rip), %rsi     # 0x34a9d
callq 0x62c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x1e9fb(%rip), %rsi     # 0x34aa0
callq 0x62c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x16177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x160d8
jmp 0x160e6
movq -0x48(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x161ba
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xf, (%rax)
jne 0x1611e
movq -0x50(%rbp), %rdi
callq 0x132b0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15120
movq -0x50(%rbp), %rdi
movl $0x10, %esi
callq 0x133a0
jmp 0x16175
movq -0x50(%rbp), %rdi
movl $0x7, %esi
callq 0x13450
testb $0x1, %al
jne 0x16132
jmp 0x16165
movq 0x33e97(%rip), %rdi     # 0x49fd0
movq 0x33e70(%rip), %rsi     # 0x49fb0
callq 0x6320
movq %rax, %rdi
leaq 0x1e955(%rip), %rsi     # 0x34aa4
callq 0x62c0
movq %rax, %rdi
leaq 0x1e942(%rip), %rsi     # 0x34aa0
callq 0x62c0
jmp 0x16173
movq -0x50(%rbp), %rdi
movl $0x3b, %esi
callq 0x12be0
jmp 0x16175
jmp 0x16177
jmp 0x16179
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0xf, (%rcx)
movb %al, -0x51(%rbp)
je 0x1619c
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1a, (%rax)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x161a5
jmp 0x161b4
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x161d0
jmp 0x16179
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarSuffix(Parser::MetaData*)
void Parser::VarSuffix(MetaData * md) {
		if (la->kind == 26 /* "[" */) {
			string * buff = new string(""); 
			Get();
			cout << " array ["; 
			if (la->kind == _number) {
				Get();
				LexString(buff);
				cout << atoi(buff->c_str()); 
			}
			Expect(27 /* "]" */);
			_array(last(md->type)); cout << "] de"; 
		} else if (la->kind == 15 /* "(" */) {
			Get();
			if (StartOf(4)) {
				VarDecl();
				while (la->kind == 25 /* "," */) {
					Get();
					VarDecl();
				}
			}
			Expect(16 /* ")" */);
			funcion(last(md->type)); md->isF = true; ;cout << " ;function q retorna"; 
		} else SynErr(60);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x30(%rax), %rax
cmpl $0x1a, (%rax)
jne 0x16316
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6500
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x1f946(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x1622e
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x132b0
movq 0x33d7d(%rip), %rdi     # 0x49fd0
leaq 0x1e854(%rip), %rsi     # 0x34aae
callq 0x62c0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x3, (%rax)
jne 0x162d3
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17810
movq -0x18(%rbp), %rdi
callq 0x6120
movq %rax, %rdi
callq 0x64a0
movl %eax, %esi
movq 0x33d34(%rip), %rdi     # 0x49fd0
callq 0x64e0
jmp 0x162d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x162c0
jmp 0x162ce
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x163cd
movq -0x38(%rbp), %rdi
movl $0x1b, %esi
callq 0x133a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17d10
movq 0x33ccb(%rip), %rdi     # 0x49fd0
leaq 0x1e7ab(%rip), %rsi     # 0x34ab7
callq 0x62c0
jmp 0x163c7
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xf, (%rax)
jne 0x163b7
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x13450
testb $0x1, %al
jne 0x16344
jmp 0x16370
movq -0x38(%rbp), %rdi
callq 0x15bd0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x19, (%rax)
jne 0x1636e
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
callq 0x15bd0
jmp 0x1634d
jmp 0x16370
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x133a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17b50
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq 0x33c27(%rip), %rdi     # 0x49fd0
leaq 0x1e70c(%rip), %rsi     # 0x34abc
callq 0x62c0
jmp 0x163c5
movq -0x38(%rbp), %rdi
movl $0x3c, %esi
callq 0x12be0
jmp 0x163c7
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::FuncDirectDcl(Parser::MetaData*)
void Parser::FuncDirectDcl(MetaData * fd) {
		string * Name = new string(""); cout<<""; 
		if (la->kind == _name) {
			Get();
		} else if (la->kind == 15 /* "(" */) {
			Get();
			FuncDcl(fd);
			Expect(16 /* ")" */);
		} else if (StartOf(9)) {
		} else SynErr(62);
		while (la->kind == 15 /* "(" */ || la->kind == 26 /* "[" */) {
			FuncSuffix(fd);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6500
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x1f743(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x16431
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x33b83(%rip), %rdi     # 0x49fd0
leaq 0x1f719(%rip), %rsi     # 0x35b6d
callq 0x62c0
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x4, (%rax)
jne 0x164a4
movq -0x50(%rbp), %rdi
callq 0x132b0
jmp 0x164ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x16491
jmp 0x1649f
movq -0x48(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x16542
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xf, (%rax)
jne 0x164d7
movq -0x50(%rbp), %rdi
callq 0x132b0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c00
movq -0x50(%rbp), %rdi
movl $0x10, %esi
callq 0x133a0
jmp 0x164fd
movq -0x50(%rbp), %rdi
movl $0x9, %esi
callq 0x13450
testb $0x1, %al
jne 0x164eb
jmp 0x164ed
jmp 0x164fb
movq -0x50(%rbp), %rdi
movl $0x3e, %esi
callq 0x12be0
jmp 0x164fd
jmp 0x164ff
jmp 0x16501
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0xf, (%rcx)
movb %al, -0x51(%rbp)
je 0x16524
movq -0x50(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1a, (%rax)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1652d
jmp 0x1653c
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16550
jmp 0x16501
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::FuncSuffix(Parser::MetaData*)
void Parser::FuncSuffix(MetaData * fd) {
		if (la->kind == 26 /* "[" */) {
			string * buff = new string(""); 
			Get();
			cout << " array ["; 
			if (la->kind == _number) {
				Get();
				LexString(buff);
				cout << atoi(buff->c_str()); 
			}
			Expect(27 /* "]" */);
			_array(last(fd->type));  cout << "] de"; 
		} else if (la->kind == 15 /* "(" */) {
			Get();
			if (StartOf(4)) {
				VarDecl();
				while (la->kind == 25 /* "," */) {
					Get();
					VarDecl();
				}
			}
			Expect(16 /* ")" */);
			funcion(last(fd->type)); cout << " ;function q retorna"; 
		} else SynErr(63);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x30(%rax), %rax
cmpl $0x1a, (%rax)
jne 0x16696
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6500
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x1f5c6(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x165ae
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x132b0
movq 0x339fd(%rip), %rdi     # 0x49fd0
leaq 0x1e4d4(%rip), %rsi     # 0x34aae
callq 0x62c0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x3, (%rax)
jne 0x16653
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17810
movq -0x18(%rbp), %rdi
callq 0x6120
movq %rax, %rdi
callq 0x64a0
movl %eax, %esi
movq 0x339b4(%rip), %rdi     # 0x49fd0
callq 0x64e0
jmp 0x16653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x16640
jmp 0x1664e
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x16746
movq -0x38(%rbp), %rdi
movl $0x1b, %esi
callq 0x133a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17d10
movq 0x3394b(%rip), %rdi     # 0x49fd0
leaq 0x1e42b(%rip), %rsi     # 0x34ab7
callq 0x62c0
jmp 0x16740
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xf, (%rax)
jne 0x16730
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x13450
testb $0x1, %al
jne 0x166c4
jmp 0x166f0
movq -0x38(%rbp), %rdi
callq 0x15bd0
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x19, (%rax)
jne 0x166ee
movq -0x38(%rbp), %rdi
callq 0x132b0
movq -0x38(%rbp), %rdi
callq 0x15bd0
jmp 0x166cd
jmp 0x166f0
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x133a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x178e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17b50
movq 0x338ae(%rip), %rdi     # 0x49fd0
leaq 0x1e393(%rip), %rsi     # 0x34abc
callq 0x62c0
jmp 0x1673e
movq -0x38(%rbp), %rdi
movl $0x3f, %esi
callq 0x12be0
jmp 0x16740
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nop
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::BitShiffOp(LEAF::AST::NODEU*&)
void Parser::BitShiffOp(ASTU &E) {
		ASTU T;  
		BitAndOrOp(E);
		while (la->kind == 30 /* "<<" */ || la->kind == 31 /* ">>" */) {
			if (la->kind == 30 /* "<<" */) {
				Get();
				BitAndOrOp(T);
				E = bin_op(BitShiftL, E, T); 
			} else {
				Get();
				BitAndOrOp(T);
				E = bin_op(BitShiftR, E, T); 
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16830
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x1e, (%rcx)
movb %al, -0x21(%rbp)
je 0x16794
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1f, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1679d
jmp 0x1681b
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1e, (%rax)
jne 0x167e1
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16830
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xc, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16816
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16830
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xd, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16771
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::BitAndOrOp(LEAF::AST::NODEU*&)
void Parser::BitAndOrOp(ASTU &E) {
		ASTU T;  
		if (la->kind == 32 /* "~" */) {
			Get();
		}
		AndOrOp(E);
		while (la->kind == _t_r_pointer || la->kind == 33 /* "|" */ || la->kind == 34 /* "^" */) {
			if (la->kind == _t_r_pointer) {
				Get();
				AndOrOp(T);
				E = bin_op(BitAnd, E, T); 
			} else if (la->kind == 33 /* "|" */) {
				Get();
				AndOrOp(T);
				E = bin_op(BitOr, E, T); 
			} else {
				Get();
				AndOrOp(T);
				E = bin_op(BitXor, E, T); 
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rax), %rax
cmpl $0x20, (%rax)
jne 0x1685a
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16980
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, -0x21(%rbp)
je 0x1689c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x21, (%rcx)
movb %al, -0x21(%rbp)
je 0x1689c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x22, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x168a8
jmp 0x1696c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x2, (%rax)
jne 0x168ec
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16980
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x9, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16967
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x21, (%rax)
jne 0x16930
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16980
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xa, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16965
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16980
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xb, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16967
jmp 0x16867
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::AndOrOp(LEAF::AST::NODEU*&)
void Parser::AndOrOp(ASTU &E) {
		ASTU T;  
		RelaOp(E);
		while (la->kind == 35 /* "&&" */ || la->kind == 36 /* "||" */) {
			if (la->kind == 35 /* "&&" */) {
				Get();
				RelaOp(T);
				E = bin_op(And, E, T); 
			} else {
				Get();
				RelaOp(T);
				E = bin_op(Or, E, T); 
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16a60
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x23, (%rcx)
movb %al, -0x21(%rbp)
je 0x169c4
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x24, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x169cd
jmp 0x16a4b
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x23, (%rax)
jne 0x16a11
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16a60
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x7, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16a46
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16a60
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x8, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x169a1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::RelaOp(LEAF::AST::NODEU*&)
void Parser::RelaOp(ASTU &E) {
		ASTU T;  
		AddOp(E);
		while (StartOf(10)) {
			switch (la->kind) {
			case 37 /* "==" */: {
				Get();
				AddOp(T);
				E = bin_op(Eq, E, T); 
				break;
			}
			case 38 /* "!=" */: {
				Get();
				AddOp(T);
				E = bin_op(Neq, E, T); 
				break;
			}
			case 39 /* ">" */: {
				Get();
				AddOp(T);
				E = bin_op(Gtr, E, T); 
				break;
			}
			case 40 /* ">=" */: {
				Get();
				AddOp(T);
				E = bin_op(GtrEq, E, T); 
				break;
			}
			case 41 /* "<" */: {
				Get();
				AddOp(T);
				E = bin_op(Less, E, T); 
				break;
			}
			case 42 /* "<=" */: {
				Get();
				AddOp(T);
				E = bin_op(LessEq, E, T); 
				break;
			}
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16c30
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x13450
testb $0x1, %al
jne 0x16a98
jmp 0x16c1e
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
addl $-0x25, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x16c19
movq -0x28(%rbp), %rax
leaq 0x1decd(%rip), %rcx     # 0x3498c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xe, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c19
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xf, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c19
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x12, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c19
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x13, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c19
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c19
movq -0x20(%rbp), %rdi
callq 0x132b0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16c30
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x11, %edi
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16a81
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::AddOp(LEAF::AST::NODEU*&)
void Parser::AddOp(ASTU&t_node) {
		ASTU t_node_2; Obj*obj2 = new Obj(); op_types op; 
		Term(t_node);
		while (la->kind == 43 /* "+" */ || la->kind == 44 /* "-" */) {
			if (la->kind == 43 /* "+" */) {
				Get();
				op = Plus; 
			} else {
				Get();
				op = Minus; 
			}
			Term(t_node_2);
			t_node = bin_op(op,t_node,t_node_2);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x48, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x17930
jmp 0x16c63
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16d30
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x2b, (%rcx)
movb %al, -0x41(%rbp)
je 0x16c9b
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x2c, (%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x16ca4
jmp 0x16d1e
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x2b, (%rax)
jne 0x16cdf
movq -0x40(%rbp), %rdi
callq 0x132b0
movl $0x2, -0x30(%rbp)
jmp 0x16cef
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x62f0
jmp 0x16d24
movq -0x40(%rbp), %rdi
callq 0x132b0
movl $0x3, -0x30(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16d30
movl -0x30(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16c78
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Term(LEAF::AST::NODEU*&)
void Parser::Term(ASTU&t_node) {
		ASTU t_node_2; Obj*obj2 = new Obj(); op_types op; 
		Factor(t_node);
		while (la->kind == _t_pointer || la->kind == 45 /* "/" */ || la->kind == 46 /* "%" */) {
			if (la->kind == _t_pointer) {
				Get();
				op = Times; 
			} else if (la->kind == 45 /* "/" */) {
				Get();
				op = Slash; 
			} else {
				Get();
				op = Mod; 
			}
			Factor(t_node_2);
			t_node = bin_op(op,t_node,t_node_2); 
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x48, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x17930
jmp 0x16d63
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x151d0
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x1, (%rcx)
movb %al, -0x41(%rbp)
je 0x16dad
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rcx
movb $0x1, %al
cmpl $0x2d, (%rcx)
movb %al, -0x41(%rbp)
je 0x16dad
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x2e, (%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x16db9
jmp 0x16e54
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1, (%rax)
jne 0x16df4
movq -0x40(%rbp), %rdi
callq 0x132b0
movl $0x4, -0x30(%rbp)
jmp 0x16e25
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x62f0
jmp 0x16e5a
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x2d, (%rax)
jne 0x16e13
movq -0x40(%rbp), %rdi
callq 0x132b0
movl $0x5, -0x30(%rbp)
jmp 0x16e23
movq -0x40(%rbp), %rdi
callq 0x132b0
movl $0x6, -0x30(%rbp)
jmp 0x16e25
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x151d0
movl -0x30(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xe380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16d78
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Parse()
void Parser::Parse() {
	t = NULL;
	la = dummyToken = new Token();
	la->val = coco_string_create(L"Dummy Token");
	Get();
	Pro();
	Expect(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, 0x28(%rax)
movl $0x28, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0xf3e0
jmp 0x16ea7
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, 0x30(%rax)
leaq 0x1dcbe(%rip), %rdi     # 0x34b7c
callq 0xeb30
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq 0x30(%rdi), %rax
movq %rcx, 0x18(%rax)
callq 0x132b0
movq -0x28(%rbp), %rdi
callq 0x13560
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x133a0
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x28, %esi
callq 0x62f0
movq -0x10(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Parser(Scanner*)
Parser::Parser(Scanner *scanner) {
	maxT = 50;

	ParserInitCaller<Parser>::CallInit(this);
	dummyToken = NULL;
	t = la = NULL;
	minErrDist = 2;
	errDist = minErrDist;
	this->scanner = scanner;
	errors = new Errors(this->scanner);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, 0x40(%rdi)
movl $0x32, (%rdi)
callq 0x17e80
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movl $0x2, 0x14(%rax)
movl 0x14(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x10, %edi
callq 0x62e0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rsi
callq 0x17080
jmp 0x16f9e
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x62f0
movq -0x18(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::dump(Struct*, int)
void dump(Struct * vd,int d){
		for (int i = 0; i < d;i++)
		{
			cout<<" "; 
		}
		cout<<";kind: "<<vd->kind<<endl; 
		if(vd->elemType!=NULL){
			dump(vd->elemType,++d);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x176b8
movq 0x3292f(%rip), %rdi     # 0x49fd0
leaq 0x1d351(%rip), %rsi     # 0x349f9
callq 0x62c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x17692
movq 0x32911(%rip), %rdi     # 0x49fd0
leaq 0x1d455(%rip), %rsi     # 0x34b1b
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x64e0
movq %rax, %rdi
movq 0x328cc(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1770e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
callq 0x17670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::last(Struct*)
Struct* last(Struct * vd){//importante
		
		if(vd->elemType==NULL){
			return vd;
		}else{
			return last(vd->elemType);
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1790d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17922
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x178e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::un_pointer(Obj*)
void un_pointer(Obj*o){//desreferenciar
		int np=o->nPars;
		int adr=o->adr;
		if(
			(o->type->kind == Struct::Pointer ||
			o->type->kind == Struct::Arr )
			&& o->type->elemType!=NULL){
			//*o=*new Obj(o->kind,o->name,o->type->elemType);
			o->type = o->type->elemType;
			//o->adr = adr;
			//o->nPars=np;
		}else{
			cout<<";Error semnatico: "<<*o->name<<" no se puede desreferenciar."<<endl;
			if(o->type->kind != Struct::Pointer){
				cout<<"; no es un puntero"<<endl;
			}
			exit(1);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0xc, 0x10(%rax)
je 0x179b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x5, 0x10(%rax)
jne 0x179d5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x179d5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x17a50
movq 0x325f4(%rip), %rdi     # 0x49fd0
leaq 0x1d140(%rip), %rsi     # 0x34b23
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x1d134(%rip), %rsi     # 0x34b36
callq 0x62c0
movq %rax, %rdi
movq 0x3259f(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0xc, 0x10(%rax)
je 0x17a46
movq 0x325a5(%rip), %rdi     # 0x49fd0
leaq 0x1d121(%rip), %rsi     # 0x34b53
callq 0x62c0
movq %rax, %rdi
movq 0x3256f(%rip), %rsi     # 0x49fb0
callq 0x6320
movl $0x1, %edi
callq 0x63d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)