LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x9, 0x10(%rax)
jne 0x17acb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x17acb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x17b3e
movq 0x324fe(%rip), %rdi     # 0x49fd0
leaq 0x1d04a(%rip), %rsi     # 0x34b23
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6280
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x9, 0x10(%rax)
je 0x17b34
movq 0x324cd(%rip), %rdi     # 0x49fd0
leaq 0x1d05c(%rip), %rsi     # 0x34b66
callq 0x62c0
movq %rax, %rdi
movq 0x32497(%rip), %rsi     # 0x49fb0
callq 0x6320
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x2, %edx
callq 0x17670
movl $0x1, %edi
callq 0x63d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xcab0
jmp 0x17b7b
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x9, 0x10(%rax)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xcab0
jmp 0x17ba9
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x6230
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x30, %edx
callq 0x6230
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x62f0
jmp 0x17c19
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x62f0
movq -0x20(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, 0x10(%rax)
jne 0x17c4c
jmp 0x17c4c
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xcab0
jmp 0x17c67
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xc, 0x10(%rax)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xcab0
jmp 0x17c95
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x6230
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x30, %edx
callq 0x6230
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x62f0
jmp 0x17d05
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x62f0
movq -0x20(%rbp), %rdi
callq 0x64f0
nop
// File: Davidc2525[P]Leaf/parser/Parser.h
// Function: Parser::make_ref(Obj*)
void make_ref(Obj*o){//referenciar
			Obj  tmp = *o;
			//*o = *new Obj();


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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0x20(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movaps %xmm3, -0x30(%rbp)
movaps %xmm2, -0x40(%rbp)
movaps %xmm1, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xcab0
jmp 0x17d99
movq -0x78(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0xc, 0x10(%rax)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0xcab0
jmp 0x17dcf
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0x62f0
jmp 0x17e2e
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0x62f0
movq -0x68(%rbp), %rdi
callq 0x64f0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movb $0x1, -0x35(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6500
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x1dc84(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x17ef0
movb $0x0, -0x35(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6340
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf320
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6500
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0xada0
jmp 0x17f47
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6550
jmp 0x17f59
leaq -0x58(%rbp), %rdi
callq 0x6588
leaq -0x59(%rbp), %rdi
callq 0x6340
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6550
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x6340
testb $0x1, -0x35(%rbp)
jne 0x17f9e
jmp 0x17fac
movq -0x78(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x17fda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x17fd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6588
leaq -0x59(%rbp), %rdi
callq 0x6340
movq -0x30(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xcab0
jmp 0x1815e
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x5, 0x10(%rax)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xcab0
jmp 0x1818c
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x6230
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x30, %edx
callq 0x6230
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x62f0
jmp 0x181fc
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x62f0
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0xe8c0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x18aa0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x18b00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x18ad0
testb $0x1, %al
jne 0x18726
jmp 0x187aa
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18bb0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq (%rax), %rdx
callq 0x18b30
testb $0x1, %al
jne 0x1874d
jmp 0x18794
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18bb0
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq (%rax), %rdx
callq 0x18be0
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18bb0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq 0x8(%rax), %rdx
callq 0xb4e0
jmp 0x18796
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x18d30
movq %rax, -0x30(%rbp)
jmp 0x18703
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::start_with(char const*, char const*)
bool start_with(const char *v1, const char *v2)
    {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6140
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x18b97
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x18b8a
movb $0x0, -0x1(%rbp)
jmp 0x18b9b
jmp 0x18b8c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18b4b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::sub_from(char const*, char const*)
const char *sub_from(const char *v1, const char *v2)
    {
        int index = to(v1, v2);
        string nc(v2);
        string nc2 = nc.substr(index);
        string *r = new string(nc2);
        return r->c_str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18da0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6500
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xada0
jmp 0x18c3f
leaq -0x41(%rbp), %rdi
callq 0x6340
movslq -0x1c(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq $-0x1, %rcx
callq 0x6300
jmp 0x18c62
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x98(%rbp)
jmp 0x18c75
movq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6130
jmp 0x18c87
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x6120
movq %rax, -0xa0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6588
leaq -0x40(%rbp), %rdi
callq 0x6588
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x6340
jmp 0x18d26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x18d1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x18d14
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x20, %esi
callq 0x62f0
leaq -0x78(%rbp), %rdi
callq 0x6588
leaq -0x40(%rbp), %rdi
callq 0x6588
movq -0x50(%rbp), %rdi
callq 0x64f0
nop
// File: Davidc2525[P]Leaf/assembly/interface/../../conf/conf.h
// Function: LEAF::CONF::Conf::to(char const*, char const*)
int to(const char *v1, const char *v2)
    {
        int index = 0;
        for (int x = 0; x < strlen(v1); x++)
        {
            if (v1[x] != v2[x])
                return index;
            index++;
        }
        return index;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6140
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x18e17
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x18e03
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18e1d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x18dc2
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x18aa0
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rdi
callq 0x18b00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18ad0
testb $0x1, %al
jne 0x19021
jmp 0x19069
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x190c0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x6440
cmpl $0x0, %eax
jne 0x19056
leaq -0x18(%rbp), %rdi
callq 0x190c0
movq 0x8(%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x19058
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x18d30
movq %rax, -0x28(%rbp)
jmp 0x19001
movl $0x1, %edi
movq %rdi, -0x58(%rbp)
callq 0x6160
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x62e0
jmp 0x19086
movq -0x50(%rbp), %rdi
leaq 0x30017(%rip), %rsi     # 0x490a8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6200
movq -0x30(%rbp), %rdi
callq 0x64f0
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/assembly/interface/sizes.cpp
// Function: size_to_string(sizes)
const char *size_to_string(sizes s)
{
	switch (s)
	{
	case none:
		return "";
	case byte:
		return "BYTE";
	case hword:
		return "";
	case word:
		return "WORD";
	case dword:
		return "DWORD";
	case qword:
		return "QWORD";
	}
	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x19a86
movq -0x18(%rbp), %rax
leaq 0x1c079(%rip), %rcx     # 0x35aa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c12e(%rip), %rax     # 0x35b6d
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c074(%rip), %rax     # 0x35ac0
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c114(%rip), %rax     # 0x35b6d
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c060(%rip), %rax     # 0x35ac6
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c052(%rip), %rax     # 0x35ac5
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c04b(%rip), %rax     # 0x35acb
movq %rax, -0x8(%rbp)
jmp 0x19a91
leaq 0x1c0e0(%rip), %rax     # 0x35b6d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6500
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x1bf83(%rip), %rsi     # 0x35b6d
callq 0xada0
jmp 0x19bf1
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x58(%rbp)
subq $0x4, %rax
ja 0x19cb6
movq -0x58(%rbp), %rax
leaq 0x1beda(%rip), %rcx     # 0x35b00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x19c4c
jmp 0x19c5a
movq -0x48(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x19cca
movq -0x18(%rbp), %rdi
leaq 0x1becc(%rip), %rsi     # 0x35b33
callq 0x6540
jmp 0x19cb8
movq -0x18(%rbp), %rdi
leaq 0x1bec8(%rip), %rsi     # 0x35b41
callq 0x6540
jmp 0x19cb8
movq -0x18(%rbp), %rdi
leaq 0x1bec4(%rip), %rsi     # 0x35b4f
callq 0x6540
jmp 0x19cb8
movq -0x18(%rbp), %rdi
leaq 0x1beba(%rip), %rsi     # 0x35b57
callq 0x6540
jmp 0x19cb8
movq -0x18(%rbp), %rdi
leaq 0x1beb5(%rip), %rsi     # 0x35b64
callq 0x6540
jmp 0x19cb8
jmp 0x19cb8
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6500
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x1acb8(%rip), %rsi     # 0x34ab5
callq 0xada0
jmp 0x19e04
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1a260
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1a2d0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a290
testb $0x1, %al
jne 0x19e58
jmp 0x19f27
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1a260
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1a290
testb $0x1, %al
jne 0x19e7c
jmp 0x19ed2
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1a300
movq (%rax), %rax
movl (%rax), %edi
callq 0x1b2b0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x6540
jmp 0x19ed2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x19ec2
jmp 0x19ed0
movq -0x70(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x19f4c
leaq -0x40(%rbp), %rdi
callq 0x1a300
movq -0x78(%rbp), %rsi
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rdi
callq 0x6120
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x6540
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x1a320
movq %rax, -0x58(%rbp)
jmp 0x19e31
movq -0x18(%rbp), %rdi
leaq 0x1abe5(%rip), %rsi     # 0x34b17
callq 0x6540
movq -0x78(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x20, %edi
callq 0x62e0
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6500
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x1babf(%rip), %rsi     # 0x35b6c
callq 0xada0
jmp 0x1a0b4
movb $0x0, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6540
movq -0x18(%rbp), %rdi
leaq 0x1a914(%rip), %rsi     # 0x349f9
callq 0x6540
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1a360
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1a3d0
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a390
testb $0x1, %al
jne 0x1a129
jmp 0x1a236
leaq -0x38(%rbp), %rdi
callq 0x1a400
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0x1a1a3
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1a400
movq (%rax), %rax
movl (%rax), %edi
callq 0x19a10
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x6540
movq -0x18(%rbp), %rdi
leaq 0x1a88d(%rip), %rsi     # 0x349f9
callq 0x6540
jmp 0x1a1a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6340
testb $0x1, -0x2d(%rbp)
jne 0x1a190
jmp 0x1a19e
movq -0x68(%rbp), %rdi
movl $0x20, %esi
callq 0x62f0
jmp 0x1a24b
leaq -0x38(%rbp), %rdi
callq 0x1a400
movq -0x70(%rbp), %rsi
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rdi
callq 0x6120
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x6540
movslq -0x3c(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1a420
movq %rax, %rcx
movq -0x80(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x1a219
movq -0x18(%rbp), %rdi
leaq 0x1b95a(%rip), %rsi     # 0x35b6e
callq 0x6540
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x1a440
movq %rax, -0x50(%rbp)
jmp 0x1a102
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nop
// File: Davidc2525[P]Leaf/assembly/implements/MemoryOperand.cpp
// Function: LEAF::ASSEMBLY::enum_load_mod_to_str(LEAF::ASSEMBLY::load_mod)
const char *LEAF::ASSEMBLY::enum_load_mod_to_str(load_mod m)
{
	switch (m)
	{
	case add:
		return "+";
		break;
	case sub:
		return "-";
		break;
	case mul:
		return "*";
		break;
	case div:
		return "/";
		break;
	case mod:
		return "%";
		break;

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x1b319
movq -0x18(%rbp), %rax
leaq 0x1a95d(%rip), %rcx     # 0x35c2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1a981(%rip), %rax     # 0x35c60
movq %rax, -0x8(%rbp)
jmp 0x1b31d
leaq 0x1acd3(%rip), %rax     # 0x35fbf
movq %rax, -0x8(%rbp)
jmp 0x1b31d
leaq 0x1a969(%rip), %rax     # 0x35c62
movq %rax, -0x8(%rbp)
jmp 0x1b31d
leaq 0x1a95e(%rip), %rax     # 0x35c64
movq %rax, -0x8(%rbp)
jmp 0x1b31d
leaq 0x1a953(%rip), %rax     # 0x35c66
movq %rax, -0x8(%rbp)
jmp 0x1b31d
jmp 0x1b31b
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x19931(%rip), %rax     # 0x35c90
movq %rax, -0x30(%rbp)
movq 0x1992e(%rip), %rax     # 0x35c98
movq %rax, -0x28(%rbp)
movl 0x1992c(%rip), %eax     # 0x35ca0
movl %eax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x1c3ac
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %esi
callq 0x1c3c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x185c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1c37e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/assembly/interface/Program.cpp
// Function: LEAF::ASSEMBLY::Program::section(LEAF::ASSEMBLY::Sections)
Section *Program::section(Sections s)
{
    map<Sections, Section *>::iterator found = sections.find(s);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1c530
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1c590
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c560
testb $0x1, %al
jne 0x1c40c
jmp 0x1c41f
leaq -0x20(%rbp), %rdi
callq 0x1c5c0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c427
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x6290
movl %eax, %edi
callq 0x62b0
movl -0x4(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
callq 0x60c0
cltd
idivl -0x4(%rbp)
movq -0x28(%rbp), %rax
movl %edx, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
jle 0x1d3d8
callq 0x60c0
movl $0x5e, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
addl $0x20, %edx
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1d3ad
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x62a0
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/tree.cpp
// Function: sreq(Struct*, Struct*)
bool sreq(Struct *o1, Struct *o2)
{
    if (o1->elemType != NULL && o2->elemType != NULL)
    {
        if (o1->kind == o2->kind)
        {
            sreq(o1->elemType, o2->elemType);
        }
        else
        {
            return false;
        }
    }
    else
    {
        if (o1->elemType == NULL && o2->elemType != NULL)
        {
            return false;
        }
        else if (o2->elemType == NULL && o1->elemType != NULL)
        {
            return false;
        }
        return o1->kind == o2->kind;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e095
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e095
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x1e08d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1e040
jmp 0x1e093
movb $0x0, -0x1(%rbp)
jmp 0x1e0e9
jmp 0x1e0e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1e0b1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e0b1
movb $0x0, -0x1(%rbp)
jmp 0x1e0e9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1e0cd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e0cd
movb $0x0, -0x1(%rbp)
jmp 0x1e0e9
jmp 0x1e0cf
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e0e9
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/tree.cpp
// Function: modoToString(EffectivePartLoadMode)
const char *modoToString(EffectivePartLoadMode mode)
{
    switch (mode)
    {
    case Add:
        return "+";
        break;
    case Sub:
        return "-";
        break;
    case Div:
        return "/";
        break;
    case Mul:
        return "*";
        break;

    default:
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1e27c
movq -0x18(%rbp), %rax
leaq 0x17ab5(%rip), %rcx     # 0x35cf4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x17a11(%rip), %rax     # 0x35c60
movq %rax, -0x8(%rbp)
jmp 0x1e280
leaq 0x17d63(%rip), %rax     # 0x35fbf
movq %rax, -0x8(%rbp)
jmp 0x1e280
leaq 0x179fb(%rip), %rax     # 0x35c64
movq %rax, -0x8(%rbp)
jmp 0x1e280
leaq 0x179ec(%rip), %rax     # 0x35c62
movq %rax, -0x8(%rbp)
jmp 0x1e280
jmp 0x1e27e
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jle 0x1e735
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x1761c(%rip), %rax     # 0x35d3e
movq %rax, (%rdi)
movq 0x2b88c(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e777
movl $0x8, %edi
callq 0x6160
movq %rax, %rdi
leaq 0x175da(%rip), %rax     # 0x35d3e
movq %rax, (%rdi)
movq 0x2b84a(%rip), %rsi     # 0x49fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x64d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, (%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
movl $0x48, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x17930
jmp 0x1e889
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x62f0
movq -0x20(%rbp), %rdi
callq 0x64f0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
popq %rbp
retq
nop
// File: Davidc2525[P]Leaf/compiler/symb_tab/struct.cpp
// Function: Struct::equals(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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x1ea39
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ea39
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x1ea31
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1e9e0
jmp 0x1ea37
movb $0x0, -0x1(%rbp)
jmp 0x1ea8d
jmp 0x1ea8b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1ea55
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ea55
movb $0x0, -0x1(%rbp)
jmp 0x1ea8d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1ea71
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ea71
movb $0x0, -0x1(%rbp)
jmp 0x1ea8d
jmp 0x1ea73
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ea8d
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1feaf
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x1fe70
movq -0x8(%rbp), %rcx
addl 0x10(%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1febc
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x48, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1fe10
jmp 0x1ff09
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1ff3c
jmp 0x1ff3c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x62f0
jmp 0x2000f
cmpl $0x1, -0x4(%rbp)
jne 0x1ffad
movq 0x2b0e7(%rip), %rax     # 0x4b030
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq 0x2b0d6(%rip), %rax     # 0x4b030
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq 0x2ae76(%rip), %rdi     # 0x4ade8
callq 0x20a90
movl (%rax), %ecx
movq 0x2b0b0(%rip), %rax     # 0x4b030
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl 0x2b0ac(%rip), %ecx     # 0x4b038
movq -0x20(%rbp), %rax
movl %ecx, 0x34(%rax)
cmpl $0x0, 0x2b09e(%rip)     # 0x4b038
jne 0x1ffab
movl 0x2b086(%rip), %eax     # 0x4b028
addl $0x1, %eax
movl %eax, 0x2b07d(%rip)     # 0x4b028
jmp 0x1ffad
movq 0x2b07c(%rip), %rax     # 0x4b030
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1ffe1
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1ffc4
cmpq $0x0, -0x40(%rbp)
jne 0x1fff9
movq -0x20(%rbp), %rcx
movq 0x2b03d(%rip), %rax     # 0x4b030
movq %rcx, 0x8(%rax)
jmp 0x20005
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64f0
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Obj *symbol_table::find(string *name)
{
    /*Obj *obj;
    Scope *scope;
    scope = curScope;
    while (scope != NULL) {  // for all open scopes
        obj = scope->locals;
        while (obj != NULL) {  // for all objects in this scope
            if (obj->name == name){
                 //cout<<" find obj: "<<obj->name<<", p: "<<obj<<endl;
                 return obj;}
            obj = obj->next;
        }
        scope = scope->outer;
    }*/
    bool ownScope = true;
    for (Scope *s = curScope; s != NULL; (s = s->outer, ownScope = false))
    {
        for (Obj *p = s->locals; p != NULL; p = p->next)
        {
            if (*p->name == *name)
            {
                /*cout<<"; find st, obj kind: "<<p->kind<<", name "<<*p->name<<", type kind: "<<p->type->kind<<endl;
                if(p->type->kind == Struct::Arr){
                    cout<<";  - elemtype kind: "<<p->type->elemType->kind<<endl;

                }*/
                //cout<<"; "<<*p->name<<" no pertenece a este ambito."<<endl;
                return p;
            }
        }
    }
    cout << "; " << *name << " is undeclared" << endl;
    return noObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq 0x2aff9(%rip), %rax     # 0x4b030
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x20099
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x20086
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x17ff0
testb $0x1, %al
jne 0x2006c
jmp 0x20076
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x200e1
jmp 0x20078
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2004e
jmp 0x20088
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
jmp 0x2003b
movq 0x29f30(%rip), %rdi     # 0x49fd0
leaq 0x149f6(%rip), %rsi     # 0x34a9d
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x15d0c(%rip), %rsi     # 0x35dce
callq 0x62c0
movq %rax, %rdi
movq 0x29edf(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x2afd3(%rip), %rax     # 0x4b0b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::findField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, Struct*)
Obj *symbol_table::findField(string *name, Struct *t)
{

    for (Obj *p = t->fields; p != NULL; p = p->next)
    {
        if (*p->name == *name)
            return p;
    }

    cout << "; " << *name << " field is undeclared" << endl;
    return symbol_table::noObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x20144
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x17ff0
testb $0x1, %al
jne 0x2012a
jmp 0x20134
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2018c
jmp 0x20136
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2010c
movq 0x29e85(%rip), %rdi     # 0x49fd0
leaq 0x1494b(%rip), %rsi     # 0x34a9d
callq 0x62c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6280
movq %rax, %rdi
leaq 0x15c5b(%rip), %rsi     # 0x35dc8
callq 0x62c0
movq %rax, %rdi
movq 0x29e34(%rip), %rsi     # 0x49fb0
callq 0x6320
movq 0x2af28(%rip), %rax     # 0x4b0b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::openScope()
void symbol_table::openScope()
{
    Scope *s = new Scope();
    s->level = curLevel;
    s->outer = curScope;
    curScope = s;
    curLevel++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x6180
movq -0x10(%rbp), %rdi
callq 0x20b70
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl 0x2ae5c(%rip), %ecx     # 0x4b038
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq 0x2ae46(%rip), %rcx     # 0x4b030
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x2ae34(%rip)     # 0x4b030
movl 0x2ae36(%rip), %eax     # 0x4b038
addl $0x1, %eax
movl %eax, 0x2ae2d(%rip)     # 0x4b038
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Davidc2525[P]Leaf/compiler/registers/register.cpp
// Function: Register::Register(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Register::Register(int id, string *name, int bits, string *word)
{
    this->id = id;
    this->name = name;
    this->bits = bits;
    this->word = word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movb $0x1, 0x20(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)