LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xc1d6
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc17a
movq 0x18e25(%rip), %rdi     # 0x24fd0
leaq 0xab77(%rip), %rsi      # 0x16d29
callq 0x5240
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc1bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd364
leaq 0xa7e3(%rip), %rcx      # 0x169c0
cmpb $0x1, 0x1a0(%rax,%rcx)
jne 0xc1f9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc6ac
pushq $0x3d
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa6a4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x17
popq %rsi
callq 0xaa9a
callq 0x8348
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xc276
movq (%r13), %rsi
movq %r15, %rdi
callq 0x8389
movq %r14, %rdi
movq %r12, %rsi
callq 0xbbc0
movq (%rbx), %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8326
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDeclDefCatch(LEAF::AST::NODEU*&)
void Parser::VarDeclDefCatch(ASTU&s) {
		int c_declaraciones = 0;
		//MetaData ** declaraciones = (MetaData**)malloc(sizeof(MetaData*)*100);
		string * Tipe = new string(""); 
		MetaData * md = new MetaData();
		VarDcl(md);
		Expect(24 /* ":" */);
		Expect(_name);
		Tipe = new string(""); LexString(Tipe);
		
		cout << " " << *Tipe <<" type kind: "<<symbol_table::find(Tipe)->type->kind<<endl<<endl; 
		
		Struct * tmp = last(md->type);
		*tmp = *symbol_table::find(Tipe)->type;	
		
		Obj * o = symbol_table::insert(Obj::Var,md->tmpName,md->type);
		
		ASTU tmp_ident = ident(md->tmpName);
		set_obj(tmp_ident,o);
		s = tmp_ident;
		dump(md->type,0);				
		
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
leaq 0xbb08(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
movq %rax, %rdi
callq 0xd10a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbc62
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0xaa9a
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xaa9a
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r12
leaq 0xbab5(%rip), %rsi      # 0x17da3
leaq 0xe(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq %r14, %rdi
movq %r12, %rsi
callq 0xd178
movq 0x18cc3(%rip), %rdi     # 0x24fd0
leaq 0xa93d(%rip), %rsi      # 0x16c51
callq 0x5240
movq %rax, %rdi
movq %r12, %rsi
callq 0x5200
leaq 0xa928(%rip), %rsi      # 0x16c53
movq %rax, %rdi
callq 0x5240
movq %rax, %r13
movq %r12, %rdi
callq 0xf34e
movq 0x18(%rax), %rax
movl 0x10(%rax), %esi
movq %r13, %rdi
callq 0x5410
movq %rax, %rdi
callq 0x5120
movq %rax, %rdi
callq 0x5120
movq 0x8(%rbx), %rax
movq %rax, %r13
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc361
movq %r12, %rdi
callq 0xf34e
movq 0x18(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
movups %xmm2, 0x20(%r13)
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
pushq $0x1
popq %rdi
callq 0xf292
movq %rax, %r12
movq 0x10(%rbx), %rdi
callq 0x8175
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x80df
movq %r13, (%r15)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xd092
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rbx
jmp 0xc3e9
jmp 0xc3e6
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0xb986(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xc48a
cmpl $0x4, %eax
jne 0xc4aa
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xd178
movq 0x18b7a(%rip), %rdi     # 0x24fd0
callq 0x5120
leaq 0xa893(%rip), %rsi      # 0x16cf5
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
movq %r15, %rsi
callq 0x5200
leaq 0xa87c(%rip), %rsi      # 0x16cf8
movq %rax, %rdi
callq 0x5240
movq %r15, 0x10(%rbx)
jmp 0xc4ff
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbc62
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xaa9a
jmp 0xc4ff
leaq 0xa50f(%rip), %rcx      # 0x169c0
cmpb $0x1, 0x16c(%rax,%rcx)
jne 0xc4e7
movq 0x18b0e(%rip), %rdi     # 0x24fd0
callq 0x5120
leaq 0xa82e(%rip), %rsi      # 0x16cfc
movq %rax, %rdi
callq 0x5240
leaq 0xa81b(%rip), %rsi      # 0x16cf8
movq %rax, %rdi
callq 0x5240
jmp 0xc4ff
pushq $0x3b
popq %rsi
movq %r14, %rdi
callq 0xa6a4
jmp 0xc4ff
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc530
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xc4f4
cmpl $0xf, %eax
je 0xc4f4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl (%rax), %eax
cmpl $0xf, %eax
je 0xc603
cmpl $0x1a, %eax
jne 0xc681
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0xb83a(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq %rbx, %rdi
callq 0xaa2e
movq 0x18a4b(%rip), %rdi     # 0x24fd0
leaq 0xa77a(%rip), %rsi      # 0x16d06
callq 0x5240
movq 0x30(%rbx), %rax
cmpl $0x3, (%rax)
jne 0xc5c3
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd178
movq (%r15), %rdi
callq 0x53d0
movq 0x18a14(%rip), %rdi     # 0x24fd0
movl %eax, %esi
callq 0x5410
pushq $0x1b
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc5d2
movq %rbx, %rdi
callq 0xd3da
movq 0x189e3(%rip), %rdi     # 0x24fd0
leaq 0xa71b(%rip), %rsi      # 0x16d0f
callq 0x5240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xaa2e
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xa3a7(%rip), %rcx      # 0x169c0
cmpb $0x1, 0xd0(%rax,%rcx)
jne 0xc63e
movq %rbx, %rdi
callq 0xc156
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
jne 0xc63e
movq %rbx, %rdi
callq 0xaa2e
jmp 0xc623
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc64d
movq %rbx, %rdi
callq 0xd2ee
movb $0x1, (%r14)
movq 0x18964(%rip), %rdi     # 0x24fd0
leaq 0xa6a1(%rip), %rsi      # 0x16d14
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5240
pushq $0x3c
popq %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa6a4
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0xb6d6(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x188ef(%rip), %rdi     # 0x24fd0
leaq 0xb6bb(%rip), %rsi      # 0x17da3
callq 0x5240
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xc709
cmpl $0x4, %eax
jne 0xc729
movq %r14, %rdi
callq 0xaa2e
jmp 0xc752
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc17a
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0xaa9a
jmp 0xc752
leaq 0xa290(%rip), %rcx      # 0x169c0
cmpb $0x0, 0x1d4(%rax,%rcx)
jne 0xc752
pushq $0x3e
popq %rsi
movq %r14, %rdi
callq 0xa6a4
jmp 0xc752
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc782
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xc747
cmpl $0xf, %eax
je 0xc747
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl (%rax), %eax
cmpl $0xf, %eax
je 0xc855
cmpl $0x1a, %eax
jne 0xc8cf
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0xb5e8(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq %rbx, %rdi
callq 0xaa2e
movq 0x187f9(%rip), %rdi     # 0x24fd0
leaq 0xa528(%rip), %rsi      # 0x16d06
callq 0x5240
movq 0x30(%rbx), %rax
cmpl $0x3, (%rax)
jne 0xc815
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd178
movq (%r15), %rdi
callq 0x53d0
movq 0x187c2(%rip), %rdi     # 0x24fd0
movl %eax, %esi
callq 0x5410
pushq $0x1b
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc824
movq %rbx, %rdi
callq 0xd3da
movq 0x18791(%rip), %rdi     # 0x24fd0
leaq 0xa4c9(%rip), %rsi      # 0x16d0f
callq 0x5240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xaa2e
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xa155(%rip), %rcx      # 0x169c0
cmpb $0x1, 0xd0(%rax,%rcx)
jne 0xc890
movq %rbx, %rdi
callq 0xc156
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
jne 0xc890
movq %rbx, %rdi
callq 0xaa2e
jmp 0xc875
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xaa9a
movq 0x8(%r14), %rax
movq %rax, %rsi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xc89f
movq %rbx, %rdi
callq 0xd2ee
movq 0x18716(%rip), %rdi     # 0x24fd0
leaq 0xa453(%rip), %rsi      # 0x16d14
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5240
pushq $0x3f
popq %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xa6a4
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc95c
movq %rsp, %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1e, %ecx
jne 0xc951
xorl %ebp, %ebp
cmpl $0x1e, %eax
sete %bpl
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xc95c
movq (%rbx), %rsi
movq (%rsp), %rdx
xorl $0xd, %ebp
movl %ebp, %edi
callq 0x8127
movq %rax, (%rbx)
jmp 0xc90f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rax
cmpl $0x20, (%rax)
jne 0xc97e
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xca20
movq %rsp, %r15
pushq $0xb
popq %rbp
pushq $0xa
popq %r12
pushq $0x9
popq %r13
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x22, %eax
je 0xc9ea
cmpl $0x21, %eax
je 0xc9cb
cmpl $0x2, %eax
jne 0xca10
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xca20
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %r13d, %edi
jmp 0xca06
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xca20
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %r12d, %edi
jmp 0xca06
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xca20
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8127
movq %rax, (%rbx)
jmp 0xc997
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xca84
movq %rsp, %r15
movq 0x30(%r14), %rax
movl (%rax), %r12d
leal -0x23(%r12), %eax
cmpl $0x1, %eax
ja 0xca78
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xca84
xorl %edi, %edi
cmpl $0x23, %r12d
movq (%rbx), %rsi
movq (%rsp), %rdx
setne %dil
addl $0x7, %edi
callq 0x8127
movq %rax, (%rbx)
jmp 0xca36
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::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xcba6
leaq 0x9f1f(%rip), %rbp      # 0x169c0
leaq 0x9efc(%rip), %r12      # 0x169a4
movq %rsp, %r15
pushq $0x11
popq %r13
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x1, 0x208(%rax,%rbp)
jne 0xcb96
addl $-0x25, %eax
cmpl $0x5, %eax
ja 0xcaaf
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
pushq $0xe
jmp 0xcb69
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
pushq $0x10
jmp 0xcb69
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
pushq $0x12
jmp 0xcb69
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
pushq $0x13
jmp 0xcb69
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
pushq $0xf
popq %rdi
callq 0x8127
movq %rax, (%rbx)
jmp 0xcaaf
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xcba6
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %r13d, %edi
jmp 0xcb6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xcc06
movq %rsp, %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
leal -0x2b(%rax), %ecx
cmpl $0x1, %ecx
ja 0xcbfb
xorl %ebp, %ebp
cmpl $0x2b, %eax
sete %bpl
movq %r14, %rdi
callq 0xaa2e
xorl $0x3, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0xcc06
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8127
movq %rax, (%rbx)
jmp 0xcbbb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbcf4
pushq $0x4
popq %r12
movq %rsp, %r15
pushq $0x5
popq %r13
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %r12d, %ebp
cmpl $0x1, %eax
je 0xcc47
cmpl $0x2e, %eax
je 0xcc44
cmpl $0x2d, %eax
jne 0xcc6d
movl %r13d, %ebp
jmp 0xcc47
pushq $0x6
popq %rbp
movq %r14, %rdi
callq 0xaa2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xbcf4
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8127
movq %rax, (%rbx)
jmp 0xcc27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x28(%rdi)
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r14
movq %rax, %rdi
callq 0x88d4
movq %r14, 0x8(%rbx)
movq %r14, 0x30(%rbx)
leaq 0xa12a(%rip), %rdi      # 0x16dd4
callq 0x8484
movq 0x30(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rbx, %rdi
callq 0xaa2e
movq %rbx, %rdi
callq 0xab9c
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaa9a
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x40(%rdi)
movl $0x32, (%rdi)
andq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
pushq $0x10
popq %rdi
callq 0x5260
andl $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Errors::printMsg(int, int, wchar_t const*)
void Errors::printMsg(int line, int col, const wchar_t *s){
	string buff = "";
	int b,li;
	li = 1;
	scanner->buffer->SetPos(0);
	while(true){
	
		b =  scanner->buffer->Read(); 
		if(b == scanner->buffer->EoF)
		 	break;
		else{
			buff.append(string((char*)&b));
			if(b==10){

			
				if(li==line){

						printf(" <-- linea %d columna %d: %ls\n", line, col, s);

				}
				if(li >= line-2 && li <= line+2)
					cout<<endl;
				
				li++;
			}else{
				if(li >= line-2 && li <= line+2)
					cout<<(char)b;
			}
		}
	}
	
			
	//printf("%ls\n",	scanner->buffer->GetString(scanner->buffer->GetPos()-(line+col),scanner->buffer->GetPos()+(line+col)));
	
	//cout<<buff<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x18(%rsp)
movl %edx, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r15
leaq 0xb00a(%rip), %rsi      # 0x17da3
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x70ae
movq 0x8(%r15), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
leal -0x2(%rbx), %r14d
movq %rbx, 0x20(%rsp)
leal 0x2(%rbx), %ecx
pushq $0x1
popq %rax
leaq 0x48(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x7(%rsp), %rbx
leaq 0x28(%rsp), %rbp
movl %r14d, 0x14(%rsp)
movl %ecx, 0x8(%rsp)
cmpl %r14d, %eax
movl %eax, %edx
setl %al
movl %edx, (%rsp)
cmpl %ecx, %edx
setg %r14b
orb %al, %r14b
movq 0x8(%r15), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0xc(%rsp)
cmpl $0x10000, %eax          # imm = 0x10000
je 0xceb3
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x70ae
movq %rbp, %rdi
movq %r12, %rsi
callq 0x5470
movq %r12, %rdi
callq 0x5488
movl 0xc(%rsp), %eax
cmpl $0xa, %eax
je 0xce5b
testb %r14b, %r14b
jne 0xcdfb
movsbl %al, %esi
movq 0x1817c(%rip), %rdi     # 0x24fd0
callq 0x52d0
jmp 0xcdfb
movq 0x20(%rsp), %rsi
movl (%rsp), %eax
cmpl %esi, %eax
jne 0xce81
leaq 0x9ede(%rip), %rdi      # 0x16d4c
movl 0x10(%rsp), %edx
movq 0x18(%rsp), %rcx
xorl %eax, %eax
callq 0x5060
movl (%rsp), %eax
movl 0x14(%rsp), %r14d
cmpl %r14d, %eax
movl %eax, %ecx
setl %al
cmpl 0x8(%rsp), %ecx
setg %cl
orb %al, %cl
jne 0xcea5
movq 0x18130(%rip), %rdi     # 0x24fd0
callq 0x5120
movl (%rsp), %eax
incl %eax
movl 0x8(%rsp), %ecx
jmp 0xcde7
leaq 0x28(%rsp), %rdi
callq 0x5488
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcee1
jmp 0xcee1
jmp 0xcee1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5488
jmp 0xcee4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::isVarDecl()
bool isVarDecl(){
    scanner->ResetPeek();
    string*n = new string("");
    string*n2 = new string(":");
    Token* x = la;
    LexStringtoken(x,n);
     // cout<<";t: "<<*n<<" = "<<(*n2==*n)<<endl;
    
    if(*n2==*n) {scanner->ResetPeek(); return true;}
    while(1){
    	nc:
      n = new string("");
      x = scanner->Peek();//la
      LexStringtoken(x,n);
      //cout<<";la: "<<*n<<" = "<<(*n2==*n)<<endl;
    
    if (*n=="["||*n=="]"||*n=="("||*n==")")
    {
    	//scanner->ResetPeek();return false;
    }
    if(*n2==*n) {scanner->ResetPeek();return true;}
    if(*n=="") {scanner->ResetPeek();return false;}
    if(*n=="=") {scanner->ResetPeek();return false;}
    
    //if(*n=="[") {scanner->ResetPeek();return false;}
    //if(*n=="]") {scanner->ResetPeek();return false;}
    }
   scanner->ResetPeek();
   return false;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xa3a6
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
leaq 0xae58(%rip), %rsi      # 0x17da3
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0x90ca(%rip), %rsi      # 0x16034
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd432
movq %r15, %rdi
movq %r14, %rsi
callq 0xd4d1
movb $0x1, %bpl
testb %al, %al
jne 0xd057
leaq 0xae00(%rip), %r13      # 0x17da3
leaq 0x9d63(%rip), %r12      # 0x16d0d
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
leaq 0x5(%rsp), %rdx
callq 0x70ae
movq 0x18(%rbx), %rdi
callq 0xa378
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd432
movq %r14, %rdi
movq %r12, %rsi
callq 0xd4fa
testb %al, %al
jne 0xd020
movq %r14, %rdi
leaq 0x9d7a(%rip), %rsi      # 0x16d6f
callq 0xd4fa
testb %al, %al
jne 0xd020
movq %r14, %rdi
leaq 0xb2c3(%rip), %rsi      # 0x182cb
callq 0xd4fa
testb %al, %al
jne 0xd020
movq %r14, %rdi
leaq 0xb115(%rip), %rsi      # 0x18130
callq 0xd4fa
movq %r15, %rdi
movq %r14, %rsi
callq 0xd4d1
movl %eax, %ebp
testb %al, %al
jne 0xd057
movq %r14, %rdi
movq %r13, %rsi
callq 0xd4fa
testb %al, %al
jne 0xd057
movq %r14, %rdi
leaq 0x9d27(%rip), %rsi      # 0x16d71
callq 0xd4fa
testb %al, %al
je 0xcfaa
movq 0x18(%rbx), %rdi
callq 0xa3a6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %r14
jmp 0xd07e
jmp 0xd07b
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq 0x17f27(%rip), %r15     # 0x24fd0
leaq 0x9cc3(%rip), %r12      # 0x16d73
leaq 0x9b9a(%rip), %r13      # 0x16c51
testl %ebx, %ebx
movl $0x0, %ebp
cmovgl %ebx, %ebp
movq %r15, %rdi
subl $0x1, %ebp
jb 0xd0d3
movq %r13, %rsi
callq 0x5240
jmp 0xd0c1
movq %r12, %rsi
callq 0x5240
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x5410
movq %rax, %rdi
callq 0x5120
movq 0x18(%r14), %r14
incl %ebx
testq %r14, %r14
jne 0xd0b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rax
movl 0x10(%rax), %ecx
cmpl $0xc, %ecx
je 0xd1f1
cmpl $0x5, %ecx
jne 0xd200
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xd200
movq %rax, 0x18(%rbx)
popq %rbx
retq
movq 0x17dc9(%rip), %rdi     # 0x24fd0
leaq 0x9b6d(%rip), %rsi      # 0x16d7b
callq 0x5240
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x9b68(%rip), %rsi      # 0x16d8e
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0x18(%rbx), %rax
cmpl $0xc, 0x10(%rax)
je 0xd25b
movq 0x17d89(%rip), %rdi     # 0x24fd0
leaq 0x9b5d(%rip), %rsi      # 0x16dab
callq 0x5240
movq %rax, %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::unwrap_call_function(Obj*)
void unwrap_call_function(Obj*o){
		int np=o->nPars;

		if(o->type->kind == Struct::Func && o->type->elemType!=NULL){
			string * return_name = o->name;
			//return_name->append(o->name->c_str());
			//*o=*new Obj(Obj::Var,return_name,o->type->elemType);
			o->kind=Obj::Var;
			o->type = o->type->elemType;
			//o->nPars =np;
		}else{
			cout<<";Error semnatico: "<<*o->name;
			if(o->type->kind != Struct::Func){
				cout<<" no es funcion"<<endl;
				dump(o->type,2);
			}
			exit(1);
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rax
cmpl $0x9, 0x10(%rax)
jne 0xd293
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xd293
movl $0x1, (%rbx)
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x17d36(%rip), %rdi     # 0x24fd0
leaq 0x9ada(%rip), %rsi      # 0x16d7b
callq 0x5240
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq 0x18(%rbx), %rax
cmpl $0x9, 0x10(%rax)
je 0xd2e6
movq 0x17d0d(%rip), %rdi     # 0x24fd0
leaq 0x9af4(%rip), %rsi      # 0x16dbe
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0x18(%rbx), %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0xd092
pushq $0x1
popq %rdi
callq 0x5300
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::funcion(Struct*)
void funcion(Struct * vd){
		Struct * cvd = new Struct();
		cvd->kind =Struct::Func;
		cvd->elemType  = new Struct();
		*cvd->elemType = *vd;
		*vd = *cvd; 
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
pushq $0x30
popq %r14
movq %r14, %rdi
callq 0x5260
movq %rax, %r15
andq $0x0, (%rax)
movabsq $0x900000000, %rax      # imm = 0x900000000
movq %rax, 0xc(%r15)
andq $0x0, 0x28(%r15)
movq %r14, %rdi
callq 0x5260
movq %rax, 0x18(%r15)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%r15), %xmm0
movups 0x20(%r15), %xmm1
movups %xmm0, (%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rbx)
movups %xmm1, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::make_ref(Obj*)
void make_ref(Obj*o){//referenciar
			Obj  tmp = *o;
			//*o = *new Obj();


			o->type = new Struct();
			o->type->kind = Struct::Pointer;
			o->type->elemType = new Struct();
			o->type->elemType = tmp.type;

			/*o->kind = tmp.kind;
			o->name = tmp.name;
			o->nPars = tmp.nPars;
			o->adr = tmp.adr;
			o->locals = tmp.locals;		*/
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r14
pushq $0x30
popq %rdi
callq 0x5260
andq $0x0, (%rax)
andl $0x0, 0xc(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x18(%rbx)
movl $0xc, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::LexStringtoken(Token*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void LexStringtoken(Token*to,string *lex){
    string * ft = new string("");
    ft->append(string(coco_string_create_char(to->val)));
    //cout<<"; ft "<<ft->c_str()<<endl;
    lex->append(*ft);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %r15
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
leaq 0xa950(%rip), %rsi      # 0x17da3
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x18(%r15), %rdi
callq 0x8873
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x70ae
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5470
leaq 0x10(%rsp), %rdi
callq 0x5488
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5470
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5488
jmp 0xd4c9
movq %rax, %r14
jmp 0xd4c9
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/Section.cpp
// Function: LEAF::ASSEMBLY::Section::Section(LEAF::ASSEMBLY::SlotVisitor*, LEAF::ASSEMBLY::Sections)
Section::Section(SlotVisitor *v, Sections type)
{
    visitor = v;
    this->type = type;

    /**
     * Agregamos el slock para la seccion.
     * ejemplo:
     * 
     * section .data
     * ...
     * section .text
     * ...
     * 
    */
    bool show_title = false;
    CONF::Conf &conf = CONF::ConfManager::get().group("leaf.compiler.asm.section.");

    if (conf.get<bool>("show_title"))
    {
        if (type == Sections::text && conf.get<bool>("text.title.show"))
        {
            show_title = true;
        }
        if (type == Sections::data && conf.get<bool>("data.title.show"))
        {
            show_title = true;
        }
        if (type == Sections::bss && conf.get<bool>("bss.title.show"))
        {
            show_title = true;
        }
        if (type == Sections::global && conf.get<bool>("global.title.show"))
        {
            show_title = true;
        }
        if (type == Sections::_extern && conf.get<bool>("extern.title.show"))
        {
            show_title = true;
        }
    }

    if (show_title)
    {
        slots.push_back(new SectionSlot(type));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
leaq 0x8(%rdi), %rbx
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rsi, 0x20(%rdi)
movl %edx, (%rdi)
callq 0x83aa
leaq 0xa661(%rip), %rsi      # 0x17ccc
movq %rax, %rdi
callq 0xd766
movq %rax, %r14
leaq 0x8a01(%rip), %rsi      # 0x1607e
movq %rax, %rdi
callq 0xd7f6
cmpl $0x5, %ebp
setb %cl
testb %cl, %al
je 0xd6ce
movl %ebp, %eax
leaq 0xa668(%rip), %rcx      # 0x17d00
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
callq 0xd7f6
testb %al, %al
je 0xd6ce
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0xe442
movq %rsp, %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0xd9b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x5270
jmp 0xd6ee
jmp 0xd6eb
movq %rax, %r14
movq %rbx, %rdi
callq 0xd92c
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::group(char const*)
Conf &group(conf_key g)
    {
        Conf *new_group = new Conf;

        for (auto x = items.begin(); x != items.end(); x++)
        {
            if (start_with(g, (*x).first))
            {
                new_group->set(sub_from(g, (*x).first), (*x).second);
            }
        }
        return *new_group;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x5260
movq %rax, %r15
addq $0x8, %rax
andl $0x0, 0x8(%r15)
andq $0x0, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
andq $0x0, 0x28(%r15)
movq 0x18(%r14), %r12
leaq 0x8(%r14), %r13
cmpq %r13, %r12
je 0xd7e9
movq 0x20(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd822
testb %al, %al
je 0xd7dc
movq 0x20(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd85a
movq 0x28(%r12), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x727c
movq %r12, %rdi
callq 0x5190
movq %rax, %r12
jmp 0xd7a3
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::start_with(char const*, char const*)
bool start_with(const char *v1, const char *v2)
    {

        for (int x = 0; x < strlen(v1); x++)
        {
            if (v1[x] != v2[x])
                return false;
        }
        return true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5100
xorl %edx, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0xd84c
movb (%r14,%rcx), %sil
leaq 0x1(%rcx), %rdx
cmpb (%rbx,%rcx), %sil
je 0xd836
cmpq %rcx, %rax
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::sub_from(char const*, char const*)
const char *sub_from(const char *v1, const char *v2)
    {
        int index = to(v1, v2);
        string nc(v2);
        string nc2 = nc.substr(index);
        string *r = new string(nc2);
        return r->c_str();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
callq 0xd8fa
movl %eax, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70ae
movslq %ebp, %rdx
movq %rsp, %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x5280
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5340
movq (%r14), %rbx
movq %rsp, %rdi
callq 0x5488
leaq 0x20(%rsp), %rdi
callq 0x5488
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xd8da
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5488
jmp 0xd8e7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::get(char const*)
conf_value get(conf_key k)
    {
        for (auto x = items.begin(); x != items.end(); x++)
        {
            if (strcmp(k, x->first) == 0)
            {
                return x->second;
            }
        }

        throw *new KeyNoFound;
        return NULL;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xd99f
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x5360
testl %eax, %eax
je 0xd995
movq %r15, %rdi
callq 0x5190
movq %rax, %r15
jmp 0xd973
movq 0x28(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x5130
leaq 0x169c2(%rip), %rsi     # 0x24370
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/implements/IntelVisitor.cpp
// Function: LEAF::ASSEMBLY::IntelVisitor::visit(LEAF::ASSEMBLY::SectionSlot*)
void IntelVisitor::visit(SectionSlot *l)
{
    string *s = new string("");

    switch (l->sect)
    {
    case Sections::text:
        s->append("section .text");
        break;
    case Sections::data:
        s->append("section .data");
        break;
    case Sections::_extern:
        s->append(";extern");
        break;
    case Sections::bss:
        s->append("section .bss");
        break;
    case Sections::global:
        s->append(";global");
        break;

    default:
        break;
    }
    this->tmp = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
leaq 0xa128(%rip), %rsi      # 0x17da3
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movl 0x8(%r15), %eax
cmpq $0x5, %rax
jae 0xdca8
leaq 0xa12f(%rip), %rcx      # 0x17dc8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
callq 0x5460
movq %r14, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/implements/IntelVisitor.cpp
// Function: LEAF::ASSEMBLY::IntelVisitor::visit(LEAF::ASSEMBLY::MemoryOperand*)
void IntelVisitor::visit(MemoryOperand *l)
{
    string *_body = new string("[");
    int c = 0;
    for (auto x = l->parts.begin(); x != l->parts.end(); x++)
    {
        if (x != l->parts.begin())
            _body->append(enum_load_mod_to_str((*x)->lm));

        (*x)->ope->accept(this);
        _body->append(this->tmp->c_str());
    }
    _body->append("]");
    this->tmp = _body;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
leaq 0x8fc3(%rip), %rsi      # 0x16d0d
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x8(%r15), %r12
cmpq 0x10(%r15), %r12
je 0xdda3
cmpq 0x8(%r15), %r12
je 0xdd7d
movq (%r12), %rax
movl (%rax), %edi
callq 0xe210
movq %r14, %rdi
movq %rax, %rsi
callq 0x5460
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5460
addq $0x8, %r12
jmp 0xdd5b
leaq 0x8fc5(%rip), %rsi      # 0x16d6f
movq %r14, %rdi
callq 0x5460
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/implements/IntelVisitor.cpp
// Function: LEAF::ASSEMBLY::IntelVisitor::visit(LEAF::ASSEMBLY::DInstruccion*)
void IntelVisitor::visit(DInstruccion *l)
{
    string *out = new string("\t");
    out->append(l->ins);
    out->append(" ");
    vector<op_pair *>::iterator x = l->operands.begin();
    int c = 0;
    for (; x != l->operands.end(); x++)
    {
        if ((*x)->load_size != none)
        {
            out->append(size_to_string((*x)->load_size));
            out->append(" ");
        }
        (*x)->operand->accept(this);
        out->append(this->tmp->c_str());
        // out->append((*x)->operand->to_string());
        if (c != l->operands.size() - 1)
        {
            out->append(",");
        }
        c++;
    }
    this->tmp = out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0x9f25(%rip), %rsi      # 0x17da2
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x5460
leaq 0x8db4(%rip), %rsi      # 0x16c51
movq %r15, %rdi
callq 0x5460
movq 0x10(%r14), %rbp
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %rbp, %rax
addq %r13, %rax
cmpq 0x18(%r14), %rax
je 0xdf35
movq (%rbp,%r12,8), %rax
movl (%rax), %edi
testl %edi, %edi
je 0xdeea
callq 0xdbf8
movq %r15, %rdi
movq %rax, %rsi
callq 0x5460
movq %r15, %rdi
leaq 0x8d71(%rip), %rsi      # 0x16c51
callq 0x5460
movq (%rbp,%r12,8), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x5460
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x3, %rax
decq %rax
cmpq %rax, %r12
je 0xdf29
movq %r15, %rdi
leaq 0x9e80(%rip), %rsi      # 0x17da4
callq 0x5460
incq %r12
addq $0x8, %r13
jmp 0xdeaf
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/Program.cpp
// Function: LEAF::ASSEMBLY::Program::Program(LEAF::ASSEMBLY::SlotVisitor*)
Program::Program(SlotVisitor *v)
{
    visitor = v;
    sections.insert(make_pair(Sections::text,
                              new Section(visitor)));
    sections.insert(make_pair(Sections::data,
                              new Section(visitor, Sections::data)));
    sections.insert(make_pair(Sections::bss,
                              new Section(visitor, Sections::bss)));
    sections.insert(make_pair(Sections::_extern,
                              new Section(visitor, Sections::_extern)));
    sections.insert(make_pair(Sections::global,
                              new Section(visitor, Sections::global)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
andl $0x0, 0x10(%rdi)
movq %rsi, %r12
andq $0x0, 0x18(%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rsi, (%rdi)
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xd6fe
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe6a6
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xd640
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe6a6
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
movq (%r14), %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0xd640
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe6a6
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
movq (%r14), %rsi
pushq $0x3
popq %rdx
movq %rax, %rdi
callq 0xd640
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe6a6
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
movq (%r14), %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0xd640
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0xe6a6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe583
jmp 0xe583
jmp 0xe583
jmp 0xe583
movq %rax, %r14
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x5270
jmp 0xe59e
jmp 0xe59b
jmp 0xe59b
jmp 0xe59b
jmp 0xe59b
movq %rax, %r14
movq %rbx, %rdi
callq 0xe64e
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/assembly/interface/Program.cpp
// Function: LEAF::ASSEMBLY::Program::section(LEAF::ASSEMBLY::Sections)
Section *Program::section(Sections s)
{
    map<Sections, Section *>::iterator found = sections.find(s);

    if (found != sections.end())
    {
        return found->second;
    }
    else
    {
        return nullptr;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x8, %rdi
movq %rax, %rsi
callq 0xe82a
addq $0x10, %rbx
cmpq %rbx, %rax
je 0xe646
movq 0x28(%rax), %rax
jmp 0xe648
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq