LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18022(%rip), %rdi     # 0x25fd8
leaq 0xcd6a(%rip), %rsi      # 0x1ad27
xorl %edx, %edx
callq 0x5300
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xdfe0
cmpl $0x4, %eax
jne 0xe002
movq %r14, %rdi
callq 0xbde8
jmp 0xe02d
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd978
movq %r14, %rdi
movl $0x10, %esi
callq 0xbe68
jmp 0xe02d
leaq 0xb957(%rip), %rcx      # 0x19960
cmpb $0x0, 0x1d4(%rax,%rcx)
jne 0xe02d
movq %r14, %rdi
movl $0x3e, %esi
callq 0xba44
jmp 0xe02d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe046
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xe022
cmpl $0xf, %eax
je 0xe022
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe11e
cmpl $0x1a, %eax
jne 0xe1cc
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rbx, %rdi
callq 0xbde8
movq 0x17f3b(%rip), %rdi     # 0x25fd8
leaq 0xbbf9(%rip), %rsi      # 0x19c9d
movl $0x8, %edx
callq 0x5300
movq 0x30(%rbx), %rax
cmpl $0x3, (%rax)
jne 0xe0e0
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xec0a
movq (%r15), %rdi
callq 0x5410
movq 0x17eff(%rip), %rdi     # 0x25fd8
movl %eax, %esi
callq 0x5460
movq %rbx, %rdi
movl $0x1b, %esi
callq 0xbe68
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xefc8
movq 0x17ecb(%rip), %rdi     # 0x25fd8
leaq 0xbb92(%rip), %rsi      # 0x19ca6
movl $0x4, %edx
jmp 0xe1be
movq %rbx, %rdi
callq 0xbde8
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xb82c(%rip), %rcx      # 0x19960
cmpb $0x1, 0xd0(%rax,%rcx)
jne 0xe187
callq 0x8ccc
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xc4aa
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
jne 0xe187
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xbde8
callq 0x8ccc
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc4aa
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
je 0xe161
movq %rbx, %rdi
movl $0x10, %esi
callq 0xbe68
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
callq 0xede6
movq 0x17e26(%rip), %rdi     # 0x25fd8
leaq 0xbaf2(%rip), %rsi      # 0x19cab
movl $0x14, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5300
movq %rbx, %rdi
movl $0x3f, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xba44
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe252
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1e, %ecx
jne 0xe247
movq %rsp, %r15
xorl %ebp, %ebp
cmpl $0x1e, %eax
sete %bpl
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe252
movq (%rbx), %rsi
movq (%rsp), %rdx
xorl $0xd, %ebp
movl %ebp, %edi
callq 0x8dc7
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1e, %ecx
je 0xe207
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe272
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe312
leaq 0x8(%rsp), %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x22, %eax
je 0xe2db
cmpl $0x21, %eax
je 0xe2b9
cmpl $0x2, %eax
jne 0xe308
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe312
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x9, %edi
jmp 0xe2fb
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe312
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xa, %edi
jmp 0xe2fb
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe312
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xb, %edi
callq 0x8dc7
movq %rax, (%rbx)
jmp 0xe282
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe386
movq 0x30(%r14), %rax
movl (%rax), %r12d
leal -0x23(%r12), %eax
cmpl $0x1, %eax
ja 0xe379
movq %rsp, %r15
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe386
xorl %edi, %edi
cmpl $0x23, %r12d
movq (%rbx), %rsi
movq (%rsp), %rdx
setne %dil
addl $0x7, %edi
callq 0x8dc7
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %r12d
leal -0x23(%r12), %eax
cmpl $0x2, %eax
jb 0xe339
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe4da
movq 0x30(%r14), %rax
movslq (%rax), %rax
leaq 0xb5b4(%rip), %r12      # 0x19960
cmpb $0x1, 0x208(%rax,%r12)
jne 0xe4cb
leaq 0xb582(%rip), %r13      # 0x19944
leaq 0x8(%rsp), %r15
addl $-0x25, %eax
cmpl $0x5, %eax
ja 0xe4b5
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xe, %edi
jmp 0xe4ad
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x10, %edi
jmp 0xe4ad
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x12, %edi
jmp 0xe4ad
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x13, %edi
jmp 0xe4ad
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0xf, %edi
jmp 0xe4ad
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4da
movq (%rbx), %rsi
movq 0x8(%rsp), %rdx
movl $0x11, %edi
callq 0x8dc7
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x0, 0x208(%rax,%r12)
jne 0xe3c7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe546
movq 0x30(%r14), %rax
movl (%rax), %eax
leal -0x2b(%rax), %ecx
cmpl $0x1, %ecx
ja 0xe53b
movq %rsp, %r15
xorl %ebp, %ebp
cmpl $0x2b, %eax
sete %bpl
movq %r14, %rdi
callq 0xbde8
xorl $0x3, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0xe546
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8dc7
movq %rax, (%rbx)
movq 0x30(%r14), %rax
movl (%rax), %eax
leal -0x2b(%rax), %ecx
cmpl $0x2, %ecx
jb 0xe4fd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd3ea
movq %rsp, %r15
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1, %eax
je 0xe57e
cmpl $0x2e, %eax
je 0xe577
cmpl $0x2d, %eax
jne 0xe5a9
movl $0x5, %ebp
jmp 0xe583
movl $0x6, %ebp
jmp 0xe583
movl $0x4, %ebp
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xd3ea
movq (%rbx), %rsi
movq (%rsp), %rdx
movl %ebp, %edi
callq 0x8dc7
movq %rax, (%rbx)
jmp 0xe55b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x957e
movq %r14, 0x8(%rbx)
movq %r14, 0x30(%rbx)
leaq 0xb785(%rip), %rdi      # 0x19d6c
callq 0x90d8
movq 0x30(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
callq 0xbf8a
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbe68
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Parser(Scanner*)
Parser::Parser(Scanner *scanner) {
	maxT = 50;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, 0x40(%rdi)
movl $0x32, (%rdi)
movq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl $0x10, %edi
callq 0x5290
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, 0x20(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb780
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xc3af(%rip), %rdx      # 0x1ad27
movq %r14, %rdi
movq %rdx, %rsi
callq 0x84ba
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
leaq 0xa682(%rip), %rsi      # 0x19020
leaq 0xa67c(%rip), %rdx      # 0x19021
movq %r15, %rdi
callq 0x84ba
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xeefa
movq 0x8(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0xe9e5
movb $0x1, %bpl
testq %rdx, %rdx
je 0xeab7
movq (%r14), %rsi
movq (%r15), %rdi
callq 0x52b0
testl %eax, %eax
je 0xeab7
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xc327(%rip), %rdx      # 0x1ad27
movq %r14, %rdi
movq %rdx, %rsi
callq 0x84ba
movq 0x18(%rbx), %rdi
callq 0xb74c
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xeefa
leaq 0xb27b(%rip), %rsi      # 0x19ca4
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xea6a
leaq 0xb2ca(%rip), %rsi      # 0x19d06
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xea6a
leaq 0xc7fc(%rip), %rsi      # 0x1b24b
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xea6a
leaq 0xc64e(%rip), %rsi      # 0x1b0b0
movq %r14, %rdi
callq 0x50d0
movq 0x8(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0xea8b
movb $0x1, %bpl
testq %rdx, %rdx
je 0xeab7
movq (%r14), %rsi
movq (%r15), %rdi
callq 0x52b0
testl %eax, %eax
je 0xeab7
leaq 0xc295(%rip), %rsi      # 0x1ad27
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0xeab5
leaq 0xb263(%rip), %rsi      # 0x19d08
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
jne 0xe9e5
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
callq 0xb780
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %r14
jmp 0xeada
jmp 0xead7
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x174d1(%rip), %r15     # 0x25fd8
leaq 0xb0e3(%rip), %r12      # 0x19bf1
leaq 0xb1f5(%rip), %r13      # 0x19d0a
movl %ebx, %ebp
testl %ebx, %ebx
jle 0xeb2f
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5300
decl %ebp
jne 0xeb1b
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
testq %r14, %r14
je 0xeb82
incl %ebx
jmp 0xeb15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeca8
cmpl $0x5, %ecx
jne 0xecbd
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xecbd
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x17314(%rip), %r14     # 0x25fd8
leaq 0xb047(%rip), %rsi      # 0x19d12
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 0xb030(%rip), %rsi      # 0x19d25
movl $0x1c, %edx
movq %rax, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5130
movq 0x18(%rbx), %rax
cmpl $0xc, 0x10(%rax)
je 0xed37
movq 0x172bd(%rip), %rbx     # 0x25fd8
leaq 0xb020(%rip), %rsi      # 0x19d42
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_O1/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 0xed70
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xed70
movl $0x1, (%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x17261(%rip), %r15     # 0x25fd8
leaq 0xaf94(%rip), %rsi      # 0x19d12
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 0xeddc
movq 0x17229(%rip), %r15     # 0x25fd8
leaq 0xaf9f(%rip), %rsi      # 0x19d55
movl $0xe, %edx
movq %r15, %rdi
callq 0x5300
movq %r15, %rdi
callq 0x5130
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0xeaf0
movl $0x1, %edi
callq 0x5340
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x30, %edi
callq 0x5290
movq %rax, %r14
xorl %r15d, %r15d
movq %r15, (%rax)
movabsq $0x900000000, %rax      # imm = 0x900000000
movq %rax, 0xc(%r14)
movq %r15, 0x18(%r14)
movq %r15, 0x28(%r14)
movl $0x30, %edi
callq 0x5290
movq %r15, (%rax)
movq %r15, 0xc(%rax)
movq %r15, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %rax, 0x18(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::puntero(Struct*)
void puntero(Struct * vd){//puntero
		if(vd->kind == Struct::Func){
			//return;
		}
		//vd->kind=2;
		Struct * cvd = new Struct();
		cvd->kind = Struct::Pointer;
		cvd->elemType  = new Struct();
		*cvd->elemType = *vd;
		*vd = *cvd; 
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl $0x30, %edi
callq 0x5290
movq %rax, %r14
xorl %r15d, %r15d
movq %r15, (%rax)
movabsq $0xc00000000, %rax      # imm = 0xC00000000
movq %rax, 0xc(%r14)
movq %r15, 0x18(%r14)
movq %r15, 0x28(%r14)
movl $0x30, %edi
callq 0x5290
movq %r15, (%rax)
movq %r15, 0xc(%rax)
movq %r15, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %rax, 0x18(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbe03(%rip), %rdx      # 0x1ad27
movq %r14, %rdi
movq %rdx, %rsi
callq 0x84ba
movq 0x18(%r15), %rdi
callq 0x9512
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xe90c
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 0xef77
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 0xefc0
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0xefbb
movq %rax, %rbx
jmp 0xefc0
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::_array1(Struct*, int)
void _array1(Struct * vd,int size){
		Struct * cvd = new Struct();
		cvd->kind = Struct::Arr;;
		cvd->elemType  = new Struct();
		*cvd->elemType = *vd;
		*vd = *cvd; 
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl $0x30, %edi
callq 0x5290
movq %rax, %r14
xorl %r15d, %r15d
movq %r15, (%rax)
movabsq $0x500000000, %rax      # imm = 0x500000000
movq %rax, 0xc(%r14)
movq %r15, 0x18(%r14)
movq %r15, 0x28(%r14)
movl $0x30, %edi
callq 0x5290
movq %r15, (%rax)
movq %r15, 0xc(%rax)
movq %r15, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %rax, 0x18(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movups (%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9062
leaq 0xbbda(%rip), %rsi      # 0x1ac64
movq %rax, %rdi
callq 0xf282
movq %rax, %r15
leaq 0x9fce(%rip), %rsi      # 0x1906a
movq %rax, %rdi
callq 0xf514
testq %rax, %rax
je 0xf0c6
cmpl $0x2, %ebp
jne 0xf0ce
leaq 0x9fda(%rip), %rsi      # 0x1908f
movq %r15, %rdi
callq 0xf514
testq %rax, %rax
setne %r12b
jmp 0xf0d1
xorl %r12d, %r12d
jmp 0xf164
xorl %r12d, %r12d
testl %ebp, %ebp
jne 0xf0f5
leaq 0x9fdd(%rip), %rsi      # 0x190b9
movq %r15, %rdi
callq 0xf514
testq %rax, %rax
movzbl %r12b, %eax
movl $0x1, %r12d
cmovel %eax, %r12d
cmpl $0x1, %ebp
jne 0xf11a
leaq 0x9fe2(%rip), %rsi      # 0x190e3
movq %r15, %rdi
callq 0xf514
testq %rax, %rax
movzbl %r12b, %eax
movl $0x1, %r12d
cmovel %eax, %r12d
cmpl $0x4, %ebp
jne 0xf13f
leaq 0xa012(%rip), %rsi      # 0x19138
movq %r15, %rdi
callq 0xf514
testq %rax, %rax
movzbl %r12b, %eax
movl $0x1, %r12d
cmovel %eax, %r12d
cmpl $0x3, %ebp
jne 0xf164
leaq 0x9fc1(%rip), %rsi      # 0x1910c
movq %r15, %rdi
callq 0xf514
testq %rax, %rax
movzbl %r12b, %eax
movl $0x1, %r12d
cmovel %eax, %r12d
testb %r12b, %r12b
je 0xf190
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
callq 0x100f2
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xf58a
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 0xf1b4
jmp 0xf1b1
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xf1c8
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x52a0
movq %r15, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf34a
movq 0x20(%r12), %rbp
movq %rbx, %rdi
callq 0x5120
testq %rax, %rax
sete %cl
je 0xf30c
movb (%rbx), %dl
cmpb (%rbp), %dl
jne 0xf30c
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0xf306
movb (%rbx,%rcx), %sil
leaq 0x1(%rcx), %rdx
cmpb (%rbp,%rcx), %sil
je 0xf2ef
cmpq %rcx, %rax
setbe %cl
testb %cl, %cl
je 0xf33a
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf35c
movq 0x28(%r12), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7dfa
movq %r12, %rdi
callq 0x51b0
movq %rax, %r12
cmpq %r13, %rax
jne 0xf2ce
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_O1/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 0xf393
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
cmpb (%rbx,%rcx), %dl
jne 0xf38e
incq %rcx
cmpq %rcx, %rax
jne 0xf37a
movq %rax, %rcx
movslq %ecx, %r14
jmp 0xf396
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe90c
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 0xf484
movq (%r14), %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf404
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf41f
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 0xf441
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf461
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52a0
jmp 0xf461
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf47c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %rbx
addq $0x8, %r15
cmpq %r15, %rbx
sete %bpl
je 0xf558
movq %rsi, %r14
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x53a0
testl %eax, %eax
je 0xf55a
movq %rbx, %rdi
callq 0x51b0
cmpq %r15, %rax
sete %bpl
je 0xf558
movq %rax, %rbx
jmp 0xf532
jmp 0xf55e
movq 0x28(%rbx), %rax
testb %bpl, %bpl
jne 0xf56e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x5140
leaq 0x15ed9(%rip), %rsi     # 0x25458
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb4c7(%rip), %rdx      # 0x1ad27
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x84ba
movl 0x8(%r15), %eax
cmpq $0x5, %rax
jae 0xf88b
leaq 0xb4d0(%rip), %rcx      # 0x1ad4c
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_O1/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 0xa36b(%rip), %rsi      # 0x19ca4
leaq 0xa365(%rip), %rdx      # 0x19ca5
movq %rbx, %rdi
callq 0x84ba
movq 0x8(%r15), %r12
cmpq 0x10(%r15), %r12
je 0xf994
cmpq 0x8(%r15), %r12
je 0xf96e
movq (%r12), %rax
movl (%rax), %edi
callq 0xfeb0
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 0xf94c
leaq 0xa36b(%rip), %rsi      # 0x19d06
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_O1/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 0xb200(%rip), %rsi      # 0x1ad26
leaq 0xb1fa(%rip), %rdx      # 0x1ad27
movq %rbx, %rdi
callq 0x84ba
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x54b0
leaq 0xa0a9(%rip), %rsi      # 0x19bf1
movq %rbx, %rdi
callq 0x54b0
movq 0x10(%r15), %rbp
cmpq 0x18(%r15), %rbp
je 0xfbeb
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rax
movl (%rax), %edi
testl %edi, %edi
je 0xfb8e
callq 0xf7d4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54b0
movq %rbx, %rdi
leaq 0xa068(%rip), %rsi      # 0x19bf1
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
subq 0x10(%r15), %rax
sarq $0x3, %rax
decq %rax
cmpq %rax, %r13
je 0xfbd2
movq %rbx, %rdi
leaq 0xb15b(%rip), %rsi      # 0x1ad28
callq 0x54b0
incq %r13
leaq (%r12,%rbp), %rax
addq $0x8, %rax
addq $0x8, %r12
cmpq 0x18(%r15), %rax
jne 0xfb64
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf1d0
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
movq %r12, 0x8(%rsi)
movq %rbx, %rdi
callq 0x10388
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xf054
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x10388
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0xf054
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x10388
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x3, %edx
callq 0xf054
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x10388
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0xf054
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x10388
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x10247
jmp 0x10247
jmp 0x10247
movq %rax, %r14
movl $0x28, %esi
movq %r15, %rdi
jmp 0x1025f
movq %rax, %r14
movl $0x28, %esi
movq %r12, %rdi
callq 0x52a0
jmp 0x10271
jmp 0x1026e
jmp 0x1026e
jmp 0x1026e
jmp 0x1026e
movq %rax, %r14
movq %rbx, %rdi
callq 0x10338
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10550
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
jg 0x1051d
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_O1/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 0x10adf
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x10adf
popq %rcx
retq
movl $0x8, %edi
callq 0x5140
leaq 0xa42e(%rip), %rcx      # 0x1af1e
movq %rcx, (%rax)
movq 0x154ce(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/threeFactory.cpp
// Function: ThreeFactory::addAstHandler(AstHandler*)
int ThreeFactory::addAstHandler(AstHandler *ast_h)
{
    int index = ids;
    handlers[index] = ast_h;
    ids++;
    return index;
}

// Assembly:
movslq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rsi, (%rcx,%rax,8)
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq %rax, 0x18(%rdi)
movq %rax, 0x28(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x20(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/struct.cpp
// Function: Struct::Struct(int, Struct*)
Struct::Struct(int kind, Struct *elemType)
{
    this->kind = kind;
    this->elemType = elemType;
    this->nFields = 0;
    this->fields = new Obj();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
movl %r14d, 0xc(%rdi)
movq %r14, 0x28(%rdi)
movl %esi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movl %r14d, 0x20(%rdi)
movl $0x48, %edi
callq 0x5290
movb $0x1, 0x4(%rax)
movb %r14b, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movb %r14b, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/struct.cpp
// Function: Struct::assign(Struct*)
void Struct::assign(Struct *o)
{
    this->kind = o->kind;
    this->elemType = (o->elemType);
    this->nFields = o->nFields;
    this->fields = o->fields;
}

// Assembly:
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
testq %rax, %rax
testq %rcx, %rcx
jne 0x10c58
testq %rax, %rax
je 0x10c4e
cmpq $0x0, 0x18(%rsi)
je 0x10c58
movl 0x10(%rdi), %ecx
movb $0x1, %al
cmpl 0x10(%rsi), %ecx
je 0x10c7b
leaq 0x16171(%rip), %rax     # 0x26dd0
movq (%rax), %rcx
cmpq %rdi, %rcx
jne 0x10c74
movl 0x10(%rsi), %edx
addl $-0x4, %edx
movb $0x1, %al
cmpl $0x3, %edx
jb 0x10c7b
cmpq %rsi, %rcx
je 0x10c7c
xorl %eax, %eax
retq
movl 0x10(%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10fcb
movl %ebx, %esi
callq 0x10fac
addl 0x10(%r14), %eax
jmp 0x10fcf
movl 0x10(%r14), %eax
addl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::insert(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, Struct*)
Obj *symbol_table::insert(int kind, string *name, Struct *type)
{
    Obj *obj = new Obj(kind, name, type);
    //cout << "; insert st, obj kind: " << kind << ", name " << *name << ", type kind: " << type->kind << ", level: " << curLevel << endl;
    if (type->kind == Struct::Arr) 
    {
       // cout << ";  - elemtype kind: " << type->elemType->kind << endl;
    }

    if (kind == Obj::Var)
    {
        //cout << ";current adr " << curScope->offset << " nvars " << curScope->nVars << endl;
        obj->adr = curScope->offset;
        curScope->nVars++;
        curScope->offset += Struct::sizes[type->kind];

        obj->level = curLevel;

        if (curLevel == 0)
        {
            globals = globals + 1;
            ;
        }
    }

    Obj *p = curScope->locals;
    Obj *last = NULL;

    while (p != NULL)
    {
        //if (*p->name == *name)
            //cout << "; " << *name << " declared twice" << endl;
        last = p;
        p = p->next;
    }

    if (last == NULL)
    {
        curScope->locals = obj;
    }
    else
    {
        last->next = obj;
    }
    // cout<<" inserted obj: "<<obj->name<<", p: "<<obj<<endl;
    return obj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x48, %edi
callq 0x5290
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10f84
cmpl $0x1, %ebp
jne 0x1104d
addq $0x10, %r14
movq 0x15d72(%rip), %rax     # 0x26d88
movl 0x10(%rax), %ecx
movl %ecx, 0x30(%rbx)
incl 0x14(%rax)
leaq 0x15b1a(%rip), %rdi     # 0x26b40
movq %r14, %rsi
callq 0x117ea
movl (%rax), %eax
movq 0x15d51(%rip), %rcx     # 0x26d88
addl %eax, 0x10(%rcx)
movl 0x15d50(%rip), %eax     # 0x26d90
movl %eax, 0x34(%rbx)
testl %eax, %eax
jne 0x1104d
incl 0x15d33(%rip)           # 0x26d80
movq 0x15d34(%rip), %rax     # 0x26d88
addq $0x8, %rax
xorl %ecx, %ecx
movq %rax, %rsi
movq %rcx, %rdx
movq (%rsi), %rcx
leaq 0x20(%rcx), %rsi
testq %rcx, %rcx
jne 0x1105d
leaq 0x20(%rdx), %rcx
testq %rdx, %rdx
cmoveq %rax, %rcx
movq %rbx, (%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470