LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::TryCatchStatement(LEAF::AST::NODEU*&)
void Parser::TryCatchStatement(ASTU&stat) {
		stat = block_try();
		Expect(22 /* "try" */);
		StatementBLock(stat);
		PartCatchStatement(stat);
		while (la->kind == 23 /* "catch" */) {
			PartCatchStatement(stat);
		}
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xd44f
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd386
movq 0x18c1d(%rip), %rdi     # 0x25fd8
leaq 0xc94f(%rip), %rsi      # 0x19d11
movl $0xa, %edx
callq 0x5300
movq 0x8(%rbx), %rax
movq %rax, %r14
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xd3d0
movl $0x30, %edi
callq 0x5290
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
movq %rcx, 0xc(%rbx)
movq %rax, 0x28(%rbx)
movl $0x30, %edi
callq 0x5290
movq %rax, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movups %xmm1, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc55a(%rip), %rcx      # 0x199b0
cmpb $0x1, 0x138(%rax,%rcx)
jne 0xd472
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdd5e
movq %r14, %rdi
movl $0x3a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba20
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xdae3
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda1a
movq 0x18589(%rip), %rdi     # 0x25fd8
leaq 0xc2ba(%rip), %rsi      # 0x19d10
movl $0xb, %edx
callq 0x5300
movq 0x8(%rbx), %rax
movq %rax, %r14
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xda64
movl $0x30, %edi
callq 0x5290
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
movq %rcx, 0xc(%rbx)
movq %rax, 0x28(%rbx)
movl $0x30, %edi
callq 0x5290
movq %rax, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movups %xmm1, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbec6(%rip), %rcx      # 0x199b0
cmpb $0x1, 0x1a0(%rax,%rcx)
jne 0xdb06
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe15c
movq %r14, %rdi
movl $0x3d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba20
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x17, %esi
callq 0xbe34
callq 0x9002
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xdb86
movq (%r13), %rsi
movq %r15, %rdi
callq 0x9047
movq %r14, %rdi
movq %r12, %rsi
callq 0xd2d0
movq (%rbx), %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8fe0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x5290
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
movq %rax, %rdi
callq 0xee24
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd386
movq %rbx, %rdi
movl $0x18, %esi
callq 0xbe34
movq %rbx, %rdi
movl $0x4, %esi
callq 0xbe34
movl $0x20, %edi
callq 0x5290
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xee9c
movq 0x183b6(%rip), %r13     # 0x25fd8
leaq 0xc018(%rip), %rsi      # 0x19c41
movl $0x1, %edx
movq %r13, %rdi
callq 0x5300
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x5300
movq %rax, %r13
leaq 0xbff2(%rip), %rsi      # 0x19c43
movl $0xc, %edx
movq %rax, %rdi
callq 0x5300
movq %r12, %rdi
callq 0x1107a
movq 0x18(%rax), %rax
movl 0x10(%rax), %esi
movq %r13, %rdi
callq 0x5460
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r13, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r13, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x8(%r15), %rax
movq %rax, %r13
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xdccd
movq %r12, %rdi
callq 0x1107a
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(%r15), %rdx
movq 0x10(%r15), %rsi
movl $0x1, %edi
callq 0x10fba
movq %rax, %r12
movq 0x10(%r15), %rdi
callq 0x8e05
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x8d67
movq %r13, (%r14)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xed84
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xde2c
cmpl $0x4, %eax
jne 0xde51
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xee9c
movq 0x18217(%rip), %r12     # 0x25fd8
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r12
leaq 0xbee9(%rip), %rsi      # 0x19cdc
movl $0x2, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x5300
leaq 0xbec9(%rip), %rsi      # 0x19cdf
movl $0x3, %edx
movq %rax, %rdi
callq 0x5300
movq %r15, 0x10(%rbx)
jmp 0xded7
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd386
movq %r14, %rdi
movl $0x10, %esi
callq 0xbe34
jmp 0xded7
leaq 0xbb58(%rip), %rcx      # 0x199b0
cmpb $0x1, 0x16c(%rax,%rcx)
jne 0xdebd
movq 0x1816f(%rip), %r15     # 0x25fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r15
leaq 0xbe49(%rip), %rsi      # 0x19ce3
movl $0x9, %edx
movq %rax, %rdi
callq 0x5300
leaq 0xbe31(%rip), %rsi      # 0x19cdf
movl $0x3, %edx
movq %r15, %rdi
callq 0x5300
jmp 0xded7
movq %r14, %rdi
movl $0x3b, %esi
callq 0xba20
jmp 0xded7
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdef4
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xdecc
cmpl $0xf, %eax
je 0xdecc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x17e4e(%rip), %rdi     # 0x25fd8
leaq 0xcbfa(%rip), %rsi      # 0x1ad8b
xorl %edx, %edx
callq 0x5300
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xe1b4
cmpl $0x4, %eax
jne 0xe1d6
movq %r14, %rdi
callq 0xbdc0
jmp 0xe201
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda1a
movq %r14, %rdi
movl $0x10, %esi
callq 0xbe34
jmp 0xe201
leaq 0xb7d3(%rip), %rcx      # 0x199b0
cmpb $0x0, 0x1d4(%rax,%rcx)
jne 0xe201
movq %r14, %rdi
movl $0x3e, %esi
callq 0xba20
jmp 0xe201
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe21a
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xe1f6
cmpl $0xf, %eax
je 0xe1f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe4ec
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1e, %ecx
jne 0xe4e1
movq %rsp, %r15
xorl %ebp, %ebp
cmpl $0x1e, %eax
sete %bpl
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4ec
movq (%rbx), %rsi
movq (%rsp), %rdx
xorl $0xd, %ebp
movl %ebp, %edi
callq 0x8db3
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1e, %ecx
je 0xe4a1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rax
cmpl $0x20, (%rax)
jne 0xe50c
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe5ac
leaq 0x8(%rsp), %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x22, %eax
je 0xe575
cmpl $0x21, %eax
je 0xe553
cmpl $0x2, %eax
jne 0xe5a2
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe5ac
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x9, %edi
jmp 0xe595
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe5ac
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xa, %edi
jmp 0xe595
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe5ac
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xb, %edi
callq 0x8db3
movq %rax, (%rbx)
jmp 0xe51c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe620
movq 0x30(%r14), %rax
movl (%rax), %r12d
leal -0x23(%r12), %eax
cmpl $0x1, %eax
ja 0xe613
movq %rsp, %r15
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe620
xorl %edi, %edi
cmpl $0x23, %r12d
movq (%rbx), %rsi
movq (%rsp), %rdx
setne %dil
addl $0x7, %edi
callq 0x8db3
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %r12d
leal -0x23(%r12), %eax
cmpl $0x2, %eax
jb 0xe5d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe774
movq 0x30(%r14), %rax
movslq (%rax), %rax
leaq 0xb36a(%rip), %r12      # 0x199b0
cmpb $0x1, 0x208(%rax,%r12)
jne 0xe765
leaq 0xb338(%rip), %r13      # 0x19994
leaq 0x8(%rsp), %r15
addl $-0x25, %eax
cmpl $0x5, %eax
ja 0xe74f
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xe, %edi
jmp 0xe747
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x10, %edi
jmp 0xe747
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x12, %edi
jmp 0xe747
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x13, %edi
jmp 0xe747
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xf, %edi
jmp 0xe747
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xe774
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x11, %edi
callq 0x8db3
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x0, 0x208(%rax,%r12)
jne 0xe661
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe7e0
movq 0x30(%r14), %rax
movl (%rax), %eax
leal -0x2b(%rax), %ecx
cmpl $0x1, %ecx
ja 0xe7d5
movq %rsp, %r15
xorl %ebp, %ebp
cmpl $0x2b, %eax
sete %bpl
movq %r14, %rdi
callq 0xbdc0
xorl $0x3, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0xe7e0
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8db3
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %eax
leal -0x2b(%rax), %ecx
cmpl $0x2, %ecx
jb 0xe797
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd486
movq %rsp, %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1, %eax
je 0xe818
cmpl $0x2e, %eax
je 0xe811
cmpl $0x2d, %eax
jne 0xe843
movl $0x5, %ebp
jmp 0xe81d
movl $0x6, %ebp
jmp 0xe81d
movl $0x4, %ebp
movq %r14, %rdi
callq 0xbdc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xd486
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8db3
movq %rax, (%rbx)
jmp 0xe7f5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, 0x28(%rdi)
movl $0x28, %edi
callq 0x5290
movq %rax, %r14
movq %rax, %rdi
callq 0x95f6
movq %r14, 0x8(%rbx)
movq %r14, 0x30(%rbx)
leaq 0xb53b(%rip), %rdi      # 0x19dbc
callq 0x90c4
movq 0x30(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rbx, %rdi
callq 0xbdc0
movq %rbx, %rdi
callq 0xbf56
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbe34
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xb764
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xc17f(%rip), %rdx      # 0x1ad8b
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8496
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
leaq 0xa3ee(%rip), %rsi      # 0x19020
leaq 0xa3e8(%rip), %rdx      # 0x19021
movq %r15, %rdi
callq 0x8496
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf05a
movq 0x8(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0xec79
movb $0x1, %bpl
testq %rdx, %rdx
je 0xed4b
movq (%r14), %rsi
movq (%r15), %rdi
callq 0x52b0
testl %eax, %eax
je 0xed4b
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xc0f7(%rip), %rdx      # 0x1ad8b
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8496
movq 0x18(%rbx), %rdi
callq 0xb736
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xf05a
leaq 0xb037(%rip), %rsi      # 0x19cf4
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xecfe
leaq 0xb086(%rip), %rsi      # 0x19d56
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xecfe
leaq 0xc5c8(%rip), %rsi      # 0x1b2ab
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xecfe
leaq 0xc41a(%rip), %rsi      # 0x1b110
movq %r14, %rdi
callq 0x50d0
movq 0x8(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0xed1f
movb $0x1, %bpl
testq %rdx, %rdx
je 0xed4b
movq (%r14), %rsi
movq (%r15), %rdi
callq 0x52b0
testl %eax, %eax
je 0xed4b
leaq 0xc065(%rip), %rsi      # 0x1ad8b
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xed49
leaq 0xb01f(%rip), %rsi      # 0x19d58
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
jne 0xec79
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
callq 0xb764
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %r14
jmp 0xed6e
jmp 0xed6b
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1723d(%rip), %r15     # 0x25fd8
leaq 0xae9f(%rip), %r12      # 0x19c41
leaq 0xafb1(%rip), %r13      # 0x19d5a
movl %ebx, %ebp
testl %ebx, %ebx
jle 0xedc3
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5300
decl %ebp
jne 0xedaf
movl $0x7, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x5300
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x5460
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbp, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x18(%r14), %r14
incl %ebx
testq %r14, %r14
jne 0xeda9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %rax
movl 0x10(%rax), %ecx
cmpl $0xc, %ecx
je 0xef1c
cmpl $0x5, %ecx
jne 0xef31
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xef31
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x170a0(%rip), %r14     # 0x25fd8
leaq 0xae23(%rip), %rsi      # 0x19d62
movl $0x12, %edx
movq %r14, %rdi
callq 0x5300
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %r14
leaq 0xae0c(%rip), %rsi      # 0x19d75
movl $0x1c, %edx
movq %rax, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5130
movq 0x18(%rbx), %rax
cmpl $0xc, 0x10(%rax)
je 0xefab
movq 0x17049(%rip), %rbx     # 0x25fd8
leaq 0xadfc(%rip), %rsi      # 0x19d92
movl $0x12, %edx
movq %rbx, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5130
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rax
cmpl $0x9, 0x10(%rax)
jne 0xefe4
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xefe4
movl $0x1, (%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x16fed(%rip), %r15     # 0x25fd8
leaq 0xad70(%rip), %rsi      # 0x19d62
movl $0x12, %edx
movq %r15, %rdi
callq 0x5300
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq 0x18(%rbx), %rax
cmpl $0x9, 0x10(%rax)
je 0xf050
movq 0x16fb5(%rip), %r15     # 0x25fd8
leaq 0xad7b(%rip), %rsi      # 0x19da5
movl $0xe, %edx
movq %r15, %rdi
callq 0x5300
movq %r15, %rdi
callq 0x5130
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0xed84
movl $0x1, %edi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rsi, %r15
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xbd07(%rip), %rdx      # 0x1ad8b
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8496
movq 0x18(%r15), %rdi
callq 0x958b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xeba0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x50f0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0d7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x50f0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf120
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0xf11b
movq %rax, %rbx
jmp 0xf120
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movl %edx, (%rdi)
callq 0x904e
leaq 0xbb56(%rip), %rsi      # 0x1acb4
movq %rax, %rdi
callq 0xf2be
movq %rax, %r15
leaq 0x9efa(%rip), %rsi      # 0x1906a
movq %rax, %rdi
callq 0xf54e
testq %rax, %rax
setne %al
cmpl $0x5, %ebp
setb %cl
testb %cl, %al
je 0xf1cc
movl %ebp, %eax
leaq 0xbb57(%rip), %rcx      # 0x1ace8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r15, %rdi
callq 0xf54e
testq %rax, %rax
je 0xf1cc
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
callq 0x1012e
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xf5ac
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x10, %esi
movq %r12, %rdi
callq 0x52a0
jmp 0xf1f0
jmp 0xf1ed
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xf204
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x52a0
movq %r15, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x5290
movq %rax, %r15
addq $0x8, %rax
movl $0x0, 0x8(%r15)
xorl %ecx, %ecx
movq %rcx, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rcx, 0x28(%r15)
movq 0x18(%r14), %r12
leaq 0x8(%r14), %r13
cmpq %r13, %r12
je 0xf37e
movq 0x20(%r12), %rbp
movq %rbx, %rdi
callq 0x5120
testq %rax, %rax
je 0xf344
movb (%rbx), %cl
cmpb (%rbp), %cl
jne 0xf36e
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0xf33f
movb (%rbx,%rcx), %sil
leaq 0x1(%rcx), %rdx
cmpb (%rbp,%rcx), %sil
je 0xf328
cmpq %rcx, %rax
ja 0xf36e
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf390
movq 0x28(%r12), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7ddc
movq %r12, %rdi
callq 0x51b0
movq %rax, %r12
cmpq %r13, %rax
jne 0xf30a
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5120
testq %rax, %rax
je 0xf3c7
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
cmpb (%rbx,%rcx), %dl
jne 0xf3c2
incq %rcx
cmpq %rcx, %rax
jne 0xf3ae
movq %rax, %rcx
movslq %ecx, %r14
jmp 0xf3ca
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xeba0
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x52c0
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf4b8
movq (%r14), %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf438
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf453
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
jmp 0xf475
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf495
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52a0
jmp 0xf495
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf4b0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xf586
movq %rsi, %rbx
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x53a0
testl %eax, %eax
je 0xf5a1
movq %r15, %rdi
callq 0x51b0
movq %rax, %r15
cmpq %r14, %rax
jne 0xf566
movl $0x1, %edi
callq 0x5140
leaq 0x15ec1(%rip), %rsi     # 0x25458
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
movq 0x28(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xb503(%rip), %rdx      # 0x1ad8b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8496
movl 0x8(%r15), %eax
cmpq $0x5, %rax
jae 0xf8b3
leaq 0xb50c(%rip), %rcx      # 0x1adb0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x54b0
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xa393(%rip), %rsi      # 0x19cf4
leaq 0xa38d(%rip), %rdx      # 0x19cf5
movq %rbx, %rdi
callq 0x8496
movq 0x8(%r15), %r12
cmpq 0x10(%r15), %r12
je 0xf9bc
cmpq 0x8(%r15), %r12
je 0xf996
movq (%r12), %rax
movl (%rax), %edi
callq 0xfee4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54b0
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x54b0
addq $0x8, %r12
jmp 0xf974
leaq 0xa393(%rip), %rsi      # 0x19d56
movq %rbx, %rdi
callq 0x54b0
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xb23c(%rip), %rsi      # 0x1ad8a
leaq 0xb236(%rip), %rdx      # 0x1ad8b
movq %rbx, %rdi
callq 0x8496
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x54b0
leaq 0xa0d1(%rip), %rsi      # 0x19c41
movq %rbx, %rdi
callq 0x54b0
movq 0x10(%r15), %rbp
cmpq 0x18(%r15), %rbp
je 0xfc19
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rax
movl (%rax), %edi
testl %edi, %edi
je 0xfbbb
callq 0xf7fc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54b0
movq %rbx, %rdi
leaq 0xa090(%rip), %rsi      # 0x19c41
callq 0x54b0
movq (%rbp,%r13,8), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x18(%r15), %rax
movq %rax, %rcx
subq 0x10(%r15), %rcx
sarq $0x3, %rcx
decq %rcx
cmpq %rcx, %r13
je 0xfc01
movq %rbx, %rdi
leaq 0xb194(%rip), %rsi      # 0x1ad8c
callq 0x54b0
movq 0x18(%r15), %rax
incq %r13
leaq (%r12,%rbp), %rcx
addq $0x8, %rcx
addq $0x8, %r12
cmpq %rax, %rcx
jne 0xfb8c
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x10(%rdi), %rax
movl $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rsi, (%rdi)
movl $0x28, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xf20c
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
movq %r12, 0x8(%rsi)
movq %rbx, %rdi
callq 0x103ce
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xf128
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x103ce
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0xf128
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x103ce
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x3, %edx
callq 0xf128
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x103ce
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0xf128
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x103ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x10283
jmp 0x10283
jmp 0x10283
movq %rax, %r14
movl $0x28, %esi
movq %r15, %rdi
jmp 0x1029b
movq %rax, %r14
movl $0x28, %esi
movq %r12, %rdi
callq 0x52a0
jmp 0x102ad
jmp 0x102aa
jmp 0x102aa
jmp 0x102aa
jmp 0x102aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x1037e
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/assembly/interface/Program.cpp
// Function: LEAF::ASSEMBLY::Program::write(std::ostream&)
void Program::write(ostream &out)
{

    Sections secs[5] = {Sections::global,
                        Sections::_extern,
                        Sections::data,
                        Sections::bss,
                        Sections::text};

    for (int x = 0; x < 5; x++)
    {
        section(secs[x])->write(out);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %r15
xorl %r12d, %r12d
leaq 0xabdd(%rip), %r13      # 0x1aee0
movl (%r13,%r12,4), %eax
movq 0x18(%r14), %rcx
movq %r15, %rdx
xorl %esi, %esi
cmpl %eax, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x1030f
movq 0x28(%rdx), %rdi
movq %rbx, %rsi
callq 0xf216
incq %r12
cmpq $0x5, %r12
jne 0x10303
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/tree.cpp
// Function: randomString(int, char*)
void randomString(int size, char *output) // pass the destination size and the destination itself
{ 

    srand(time(NULL)); // seed with time

    char src[size];
    size = rand() % size; // this randomises the size (optional)

    src[size] = '\0'; // start with the end of the string...

    // ...and work your way backwards
    while (--size > -1)
        src[size] = (rand() % 94) + 32; // generate a string ranging from the space character to ~ (tilde)

    strcpy(output, src); // store the random string
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r15d
xorl %edi, %edi
callq 0x5230
movl %eax, %edi
callq 0x5250
movl %r15d, %eax
movq %rsp, %r14
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
callq 0x50b0
cltd
idivl %r15d
movslq %edx, %rax
movb $0x0, (%rax,%r14)
testl %eax, %eax
jle 0x10594
movl %edx, %r15d
incq %r15
callq 0x50b0
cltq
imulq $-0x51b3bea3, %rax, %rcx # imm = 0xAE4C415D
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
shrl $0x6, %ecx
addl %edx, %ecx
imull $0x5e, %ecx, %ecx
subl %ecx, %eax
addb $0x20, %al
movb %al, -0x2(%r14,%r15)
decq %r15
cmpq $0x1, %r15
ja 0x10561
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5240
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/threeFactory.cpp
// Function: ThreeFactory::getAstHandler(int)
AstHandler *ThreeFactory::getAstHandler(int id)
{
    if (id > ids)
    {
        // cout << "Manejador no registrado: "<<id;
        throw "Manejador no registrador";
        //exit(1);
    }

    AstHandler *found = handlers[id];
    if (!found)
    {
        //cout << "Manejador no registrado";
        throw "Manejador no registrador";
    }

    return found;
}

// Assembly:
pushq %rax
cmpl %esi, (%rdi)
jl 0x10af7
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x10af7
popq %rcx
retq
movl $0x8, %edi
callq 0x5140
leaq 0xa476(%rip), %rcx      # 0x1af7e
movq %rcx, (%rax)
movq 0x154b6(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/symb_tab/struct.cpp
// Function: Struct::Struct(int)
Struct::Struct(int kind)
{
    this->kind = kind;
    this->nFields = 0;
    this->fields = NULL;
    this->elemType = NULL;
}

// Assembly:
xorl %eax, %eax
movq %rax, (%rdi)
movl %eax, 0xc(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/symb_tab/struct.cpp
// Function: Struct::compatibleWith(Struct*)
bool Struct::equals(Struct *other)
{
    if (this->elemType != NULL && other->elemType != NULL)
    {
        if (this->kind == other->kind)
        {
            this->elemType->equals(other->elemType);
        }
        else
        {
            return false;
        }
    }
    else
    {
        if (this->elemType == NULL && other->elemType != NULL)
        {
            return false;
        }
        else if (other->elemType == NULL && this->elemType != NULL)
        {
            return false;
        }
        return this->kind == other->kind;
    }
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
jne 0x10c48
cmpq $0x0, 0x18(%rsi)
jne 0x10c48
movl 0x10(%rdi), %ecx
movb $0x1, %al
cmpl 0x10(%rsi), %ecx
je 0x10c6b
leaq 0x16181(%rip), %rax     # 0x26dd0
movq (%rax), %rcx
cmpq %rdi, %rcx
jne 0x10c64
movl 0x10(%rsi), %edx
addl $-0x4, %edx
movb $0x1, %al
cmpl $0x3, %edx
jb 0x10c6b
cmpq %rsi, %rcx
je 0x10c6c
xorl %eax, %eax
retq
movl 0x10(%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::get_id(Struct*, int)
int symbol_table::get_id(Struct *type, int ac) 
{
    int id = ac;
    //cout<<"kind "<<type->kind<<endl;
    if (type->elemType != NULL)
    {
        id = get_id(type->elemType, id) + type->kind+id;
    }
    else
    {
        id+= type->kind;
    }

    return id;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x10fab
movl %ebx, %esi
callq 0x10f8c
addl 0x10(%r14), %eax
jmp 0x10faf
movl 0x10(%r14), %eax
addl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop