LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r15d
xorl %edi, %edi
callq 0x5210
movl %eax, %edi
callq 0x5230
movl %r15d, %eax
movq %rsp, %r14
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
callq 0x50a0
cltd
idivl %r15d
movl %edx, %r15d
movslq %edx, %rax
movb $0x0, (%rax,%r14)
pushq $0x5e
popq %r12
testl %r15d, %r15d
jle 0xe8e9
leaq -0x1(%r15), %r13
callq 0x50a0
cltd
idivl %r12d
addb $0x20, %dl
movb %dl, -0x1(%r14,%r15)
movq %r13, %r15
jmp 0xe8ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5220
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/tree.cpp
// Function: EffectiveAddr::toString()
char *EffectiveAddr::toString()
{
    RegisterProvider *rp = RegisterManager::getInstance()->getProviderBy(64);
    string *addr = new string();

    /**
     * TODO: delete
     * TODO: colocar el registro dependiendo de la arquitectura
    */
    if (withBp)
    {
        //  RegisterProvider *rp = RegisterManager::getInstance()->getProviderBy(64);

        addr->append(rp->get_by_name("rbp")->getName());
        addr->append("+");
    }

    if (!this->parts.empty())
    {
        //std::sort(regis.begin(), regis.end(), compareEfectivePart);

        for (int i = 0; i < parts.size(); i++)
        {

            if (i != 0)
                addr->append(modoToString(parts[i]->mode));
            if (parts[i]->type == Reg)
            {

                addr->append(rp->get(parts[i]->load)->getName());
            }
            else if (parts[i]->type == Num)
            {
                addr->append(to_string(parts[i]->load));
            }
        }
    }

    return (char *)addr->c_str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xfafc
pushq $0x40
popq %rsi
movq %rax, %rdi
callq 0xfb88
movq %rax, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
cmpb $0x1, (%rbx)
jne 0xec45
movq (%r14), %rax
leaq 0x937d(%rip), %rsi      # 0x17f9a
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %rdi
callq 0xfa1e
movq %r15, %rdi
movq %rax, %rsi
callq 0x5460
leaq 0x925b(%rip), %rsi      # 0x17e98
movq %r15, %rdi
callq 0x5460
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0xecec
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
leaq 0x15933(%rip), %rbp     # 0x24598
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0xecec
testq %r13, %r13
je 0xec8f
movq (%rax,%r13,8), %rax
movslq 0x4(%rax), %rax
movq (%rbp,%rax,8), %rsi
movq %r15, %rdi
callq 0x5460
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movl 0x8(%rax), %ecx
cmpl $0x1, %ecx
je 0xecbf
testl %ecx, %ecx
jne 0xecdc
movl (%rax), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rax, %rdi
callq 0xfa1e
movq %r15, %rdi
movq %rax, %rsi
callq 0x5460
jmp 0xecdc
movl (%rax), %esi
movq %r12, %rdi
callq 0x70e9
movq %r15, %rdi
movq %r12, %rsi
callq 0x5470
movq %r12, %rdi
callq 0x5488
incq %r13
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
jmp 0xec65
movq (%r15), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xed85
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0xed85
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x920a(%rip), %rcx      # 0x17f9e
movq %rcx, (%rax)
movq 0x16222(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
andl $0x0, 0xc(%rdi)
andq $0x0, 0x28(%rdi)
movl %esi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
andl $0x0, 0x20(%rdi)
pushq $0x48
popq %rdi
callq 0x5260
movb $0x1, 0x4(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movb %cl, 0x28(%rax)
orl $-0x1, 0x30(%rax)
movq %rax, 0x28(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf283
movl %ebx, %esi
callq 0xf264
addl 0x10(%r14), %eax
jmp 0xf287
movl 0x10(%r14), %eax
addl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x5260
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xf244
movq 0x16aa5(%rip), %rax     # 0x25d68
cmpl $0x1, %ebp
jne 0xf303
addq $0x10, %r14
movl 0x10(%rax), %ecx
movl %ecx, 0x30(%rbx)
incl 0x14(%rax)
leaq 0x16844(%rip), %rdi     # 0x25b20
movq %r14, %rsi
callq 0xf88c
movl (%rax), %ecx
movq 0x16a7b(%rip), %rax     # 0x25d68
addl %ecx, 0x10(%rax)
movl 0x16a7a(%rip), %ecx     # 0x25d70
movl %ecx, 0x34(%rbx)
testl %ecx, %ecx
jne 0xf303
incl 0x16a5d(%rip)           # 0x25d60
addq $0x8, %rax
xorl %ecx, %ecx
movq %rax, %rsi
movq %rcx, %rdx
movq (%rsi), %rcx
leaq 0x20(%rcx), %rsi
testq %rcx, %rcx
jne 0xf30c
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
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x16a0b(%rip), %r15     # 0x25d68
movq (%r15), %r15
testq %r15, %r15
je 0xf387
leaq 0x8(%r15), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xf35d
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd4d1
testb %al, %al
jne 0xf3c3
addq $0x20, %r14
jmp 0xf369
movq 0x15c42(%rip), %rdi     # 0x24fd0
leaq 0x7960(%rip), %rsi      # 0x16cf5
callq 0x5240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5200
leaq 0x8c82(%rip), %rsi      # 0x1802e
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0x16a25(%rip), %r14     # 0x25de8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xf3f8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd4d1
testb %al, %al
jne 0xf434
addq $0x20, %r14
jmp 0xf3da
movq 0x15bd1(%rip), %rdi     # 0x24fd0
leaq 0x78ef(%rip), %rsi      # 0x16cf5
callq 0x5240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5200
leaq 0x8c0b(%rip), %rsi      # 0x18028
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0x169b4(%rip), %r14     # 0x25de8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
pushq $0x20
popq %rdi
callq 0x5260
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x8, 0x10(%rax)
movl 0x16910(%rip), %ecx     # 0x25d70
movl %ecx, 0x18(%rax)
movq 0x168fe(%rip), %rdx     # 0x25d68
movq %rdx, (%rax)
movq %rax, 0x168f4(%rip)     # 0x25d68
incl %ecx
movl %ecx, 0x168f4(%rip)     # 0x25d70
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register.cpp
// Function: Register::dump()
const char *Register::dump()
{
    string *d_info = new string("Register@{");
    d_info->append("name: ");
    d_info->append(name->c_str());
    d_info->append(",bits: ");
    d_info->append(to_string(bits));
    d_info->append("}");
    return d_info->c_str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
leaq 0x8623(%rip), %rsi      # 0x18065
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x70ae
leaq 0x861a(%rip), %rsi      # 0x18070
movq %rbx, %rdi
callq 0x5460
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5460
leaq 0x8603(%rip), %rsi      # 0x18077
movq %rbx, %rdi
callq 0x5460
movl 0x10(%r14), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x70e9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5470
leaq 0x8(%rsp), %rdi
callq 0x5488
leaq 0x85d6(%rip), %rsi      # 0x1807f
movq %rbx, %rdi
callq 0x5460
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5488
jmp 0xfad9
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5420
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_manager.cpp
// Function: RegisterManager::getProviderBy(int)
RegisterProvider *RegisterManager::getProviderBy(int arc)
{
    RegisterProvider *provider = NULL;

    for (int p = 0; p < ids; p++)
    {
        if(arc==providers[p]->getArc()){
            provider = providers[p];
            return provider;
        }
    }
    if(provider == NULL){
        throw "Proveedor no existe";
    }

    return provider;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0xfbc2
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
incq %r14
cmpl %ebp, %eax
jne 0xfb94
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x84b0(%rip), %rcx      # 0x18081
movq %rcx, (%rax)
movq 0x153e5(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::lessBussy()
Register *RegisterProvider::lessBussy()
{
    Register *less = NULL;
    int gtr = 1000000;
    for (auto x = registers_.begin(); x != registers_.end(); x++)
    {
        if ((*reservers)[(*x)->id]->size() < gtr && (*x)->bits == getArc())
        {
            gtr = (*reservers)[(*x)->id]->size();
            less = get((*x)->id);
        }
    }
    if (less == NULL)
    {
        throw "No se pudo encotrar el registro menos usado.";
    }
    return less;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movl $0xf4240, %r14d         # imm = 0xF4240
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r12
je 0xfc6a
movq 0x20(%rbx), %rdi
movq (%r12), %rsi
callq 0x101a2
movq (%rax), %rdi
callq 0x1045e
movslq %r14d, %rcx
cmpq %rcx, %rax
jae 0xfc64
movq (%r12), %rax
movl 0x10(%rax), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x88(%rax)
cmpl %eax, %ebp
jne 0xfc64
movq 0x20(%rbx), %rdi
movq (%r12), %rsi
callq 0x101a2
movq (%rax), %rdi
callq 0x1045e
movq %rax, %r14
movq (%r12), %rax
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r15
addq $0x8, %r12
jmp 0xfc00
testq %r15, %r15
je 0xfc7b
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x840b(%rip), %rcx      # 0x18095
movq %rcx, (%rax)
movq 0x1532c(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::get_by_name2(char*)
Register *RegisterProvider::get_by_name2(char *name)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        if (0 == strcmp(name, ((Register *)*x)->getName()))
        {
            int dis = distance(it, x);
            found = registers_[dis];
        }
    }
    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
movabsq $0x100000000, %rbp      # imm = 0x100000000
xorl %r15d, %r15d
cmpq 0x10(%r14), %r12
je 0xfd6f
movq (%r12), %rdi
callq 0xfa1e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5360
testl %eax, %eax
jne 0xfd66
movq 0x8(%r14), %rax
movq %r13, %rcx
sarq $0x1d, %rcx
movq (%rax,%rcx), %r15
addq $0x8, %r12
addq %rbp, %r13
jmp 0xfd39
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::free_by_name2(char*)
void RegisterProvider::free_by_name2(char *name)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        if (0 == strcmp(name, ((Register *)*x)->getName()))
        {
            (*reservers)[(*x)->id]->pop();
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rbx), %r15
je 0xfddc
movq (%r15), %rdi
callq 0xfa1e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5360
testl %eax, %eax
je 0xfde2
addq $0x8, %r15
jmp 0xfdb9
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rdi
movq (%r15), %rsi
callq 0x101a2
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x104a6
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::reserve()
Register *RegisterProvider::reserve()
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        //cout<<"bussi: "<<isBussy((*x)->id)<<" reg: "<<(*x)->getName()<<" arc: "<< getArc()<<endl;
        if (!isBussy((*x)->id) && (*x)->bits == getArc() && (*x)->reservable)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }
    if (found == NULL)
    {
        found = lessBussy();
    }
    if (found == NULL)
    {
        throw "No hay Registro disponible";
    }

    (*reservers)[found->id]->push(1);
    //cout<<"top: "<<(*reservers)[found->id]->size()<<",bussy: "<<((*reservers)[found->id]->size()>0)<<",csm : "<<isBussy(found->id)<<endl;
    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
movabsq $0x100000000, %r12      # imm = 0x100000000
cmpq 0x10(%rbx), %r15
je 0xfe78
movq (%r15), %rax
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0xfe5e
movq (%r15), %rax
movl 0x10(%rax), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x88(%rax)
cmpl %eax, %ebp
jne 0xfe5e
movq (%r15), %rax
cmpb $0x0, 0x20(%rax)
jne 0xfe67
addq $0x8, %r15
addq %r12, %r14
jmp 0xfe28
movq 0x8(%rbx), %rax
sarq $0x1d, %r14
movq (%rax,%r14), %r14
testq %r14, %r14
jne 0xfe89
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rax, %r14
testq %rax, %rax
je 0xfeb8
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x101a2
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x104fc
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x81fb(%rip), %rcx      # 0x180c2
movq %rcx, (%rax)
movq 0x150ef(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/registers/register_provider.cpp
// Function: RegisterProvider::reserve_by_size(int)
Register *RegisterProvider::reserve_by_size(int size)
{
    Register *found = NULL;
    vector<Register *>::iterator it = registers_.begin();
    for (std::vector<Register *>::iterator x = it; x != registers_.end(); x++)
    {
        //cout<<"bussi: "<<isBussy((*x)->id)<<" reg: "<<(*x)->getName()<<" arc: "<< getArc()<<endl;
        if (!isBussy((*x)->id)&&(*x)->reservable && (*x)->bits == size)
        {
            int dis = distance(it, x);
            found = registers_[dis];
            break;
            //cout << ";index: " << dis << " reg: " << registers_[dis]->getName() << endl;
        }
    }

    if (found == NULL)
    {
        throw "No hay Registro disponible";
    }

    (*reservers)[found->id]->push(1);
    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
movabsq $0x100000000, %r12      # imm = 0x100000000
cmpq 0x10(%rbx), %r15
je 0x100ce
movq (%r15), %rax
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0x10085
movq (%r15), %rax
cmpb $0x1, 0x20(%rax)
jne 0x10085
cmpl %ebp, 0x10(%rax)
je 0x1008e
addq $0x8, %r15
addq %r12, %r14
jmp 0x10060
movq 0x8(%rbx), %rax
sarq $0x1d, %r14
movq (%rax,%r14), %r14
testq %r14, %r14
je 0x100ce
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x101a2
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x104fc
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x7fe5(%rip), %rcx      # 0x180c2
movq %rcx, (%rax)
movq 0x14ed9(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::DeclFuncNode::load(int)
void DeclFuncNode::load(int R)
{
    RegisterProvider *rp = RegisterManager::getInstance()->getProviderBy(64);

    loadOpt->effectivea->parts.push_back(new EffectivePart(rp->reserve_by_size(128)->id));
    loadOpt->effectivea->parts.push_back(new EffectivePart(rp->reserve_by_size(32)->id));
    loadOpt->effectivea->parts.push_back(new EffectivePart(8, Num, Mul));
    loadOpt->effectivea->parts.push_back(new EffectivePart(8, Num, Mul));

    cout << "funcion: " << *name << " '" << loadOpt->effectivea->toString() << "'" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xfafc
pushq $0x40
popq %rsi
movq %rax, %rdi
callq 0xfb88
movq %rax, %r14
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
pushq $0xc
popq %rdi
callq 0x5260
movq %rax, %r12
movq (%r14), %rax
movq %r14, %rdi
movl $0x80, %esi
callq *0x78(%rax)
movl (%rax), %esi
movq %r12, %rdi
callq 0xeb88
addq $0x8, %r15
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x13408
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
pushq $0xc
popq %rdi
callq 0x5260
movq %rax, %r12
movq (%r14), %rax
pushq $0x20
popq %rsi
movq %r14, %rdi
callq *0x78(%rax)
movl (%rax), %esi
movq %r12, %rdi
callq 0xeb88
addq $0x8, %r15
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x13408
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r14
pushq $0xc
popq %rdi
callq 0x5260
movq %rax, %r15
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
movq %rax, %rdi
callq 0xebac
addq $0x8, %r14
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x13408
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r14
pushq $0xc
popq %rdi
callq 0x5260
movq %rax, %r15
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
movq %rax, %rdi
callq 0xebac
addq $0x8, %r14
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x13408
movq 0x12297(%rip), %rdi     # 0x24fd0
leaq 0x54d0(%rip), %rsi      # 0x18210
callq 0x5240
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x54c2(%rip), %rsi      # 0x1821a
movq %rax, %rdi
callq 0x5240
movq %rax, %r14
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0xebce
movq %r14, %rdi
movq %rax, %rsi
callq 0x5240
leaq 0x5499(%rip), %rsi      # 0x1821b
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x12da0
movq %rax, %rbx
pushq $0xc
popq %rsi
movq %r15, %rdi
jmp 0x12db6
jmp 0x12dad
movq %rax, %rbx
pushq $0xc
popq %rsi
movq %r12, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::StatementBlockNode::load(int)
void StatementBlockNode::load(int R)
{

    for (int x = 0; x < s; x++)
    {
        //cout<<stms[x]<<endl;
        stms[x]->load(1);
        if (!stms[x]->obj->_extern)
            cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movq 0x121b1(%rip), %r14     # 0x24fd0
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jge 0x12e56
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *(%rax)
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x28(%rax)
jne 0x12e51
movq %r14, %rdi
callq 0x5120
incq %r15
jmp 0x12e1f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64/x86_64.cpp
// Function: CODE_GENERATOR::x86_64::x86_64Linux::EmptyNode()
void x86_64Linux::GenerateCode(AST A, ExternSymbols *es, StringLiterals *sl)
{
    cout << ";-----------------------------" << endl;
    cout << "section .data" << endl;
    sl->dump();
    cout << "formato db \"%d\",10,0" << endl;
    cout << "formato_real db \"%f\",10,0" << endl;
    cout << "formato_string db \"%s\",0" << endl;
    cout << "formato_char db \"%c\",10,0" << endl;
    cout << "" << endl;
    cout << "section .text" << endl;
    cout << "global main" << endl;
    cout << "extern printf" << endl;
    es->dump();
    cout << "" << endl;

    A->load(1);
    printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq 0x120c2(%rip), %r14     # 0x24fd0
leaq 0x5308(%rip), %rsi      # 0x1821d
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x4e4b(%rip), %rsi      # 0x17d77
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq %r12, %rdi
callq 0x1309e
leaq 0x52f1(%rip), %rsi      # 0x1823c
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x52ef(%rip), %rsi      # 0x18251
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x52f2(%rip), %rsi      # 0x1826b
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x52f4(%rip), %rsi      # 0x18284
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x4dfc(%rip), %r12      # 0x17da3
movq %r14, %rdi
movq %r12, %rsi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x4da8(%rip), %rsi      # 0x17d69
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x52c6(%rip), %rsi      # 0x1829e
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
leaq 0x52bb(%rip), %rsi      # 0x182aa
movq %r14, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x1317e
movq %r14, %rdi
movq %r12, %rsi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq (%rbx), %rax
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *(%rax)
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5350
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::init(LEAF::AST::NODEU*)
void x86_64_linux_generator_visitor::init(ASTU start)
{
    cout << "x86_64 linux visitor" << endl;
    if (start == nullptr)
        return;
    assembly->get_program()->section(Sections::global)->add(new DInstruccion("global main"));
    assembly->get_program()->section(Sections::_extern)->add(new DInstruccion("extern printf"));
    assembly->get_program()->section(Sections::_extern)->add(new DInstruccion("extern puts"));

    reg = rp->reserve();
    start->accept(this);

    //3 espacio para firmar el archivo
    *out_file << endl;
    *out_file << endl;
    *out_file << endl;

    *out_file << "%include \"feactures/exceptions/linux64.asm\"" << endl;
    assembly->get_program()->write(*out_file);
    cout << "visits: " << visits_ins << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x11981(%rip), %rdi     # 0x24fd0
leaq 0x4d3d(%rip), %rsi      # 0x18393
callq 0x5240
movq %rax, %rdi
callq 0x5120
testq %r14, %r14
je 0x1379e
movq 0x10(%rbx), %rax
movq (%rax), %rdi
pushq $0x4
popq %rsi
callq 0xe61c
movq %rax, %r12
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0x4c0e(%rip), %rsi      # 0x1829e
movq %rax, %rdi
callq 0xdf60
movq %r12, %rdi
movq %r15, %rsi
callq 0xd750
movq 0x10(%rbx), %rax
movq (%rax), %rdi
pushq $0x3
popq %rsi
callq 0xe61c
movq %rax, %r12
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0x4be3(%rip), %rsi      # 0x182aa
movq %rax, %rdi
callq 0xdf60
movq %r12, %rdi
movq %r15, %rsi
callq 0xd750
movq 0x10(%rbx), %rax
movq (%rax), %rdi
pushq $0x3
popq %rsi
callq 0xe61c
movq %rax, %r12
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r15
leaq 0x4caa(%rip), %rsi      # 0x183a8
movq %rax, %rdi
callq 0xdf60
movq %r12, %rdi
movq %r15, %rsi
callq 0xd750
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x18(%rbx), %rdi
callq 0x5120
movq 0x18(%rbx), %rdi
callq 0x5120
movq 0x18(%rbx), %rdi
callq 0x5120
movq 0x18(%rbx), %rdi
leaq 0x4c64(%rip), %rsi      # 0x183b4
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rsi
movq (%rax), %rdi
callq 0xe5d4
movq 0x1185c(%rip), %rdi     # 0x24fd0
leaq 0x4c65(%rip), %rsi      # 0x183e0
callq 0x5240
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x5410
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5120
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x137ae
jmp 0x137ae
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit2(LEAF::AST::BinOp*)
void x86_64_linux_generator_visitor::visit2(BinOp *bin)
{
    UPDATE_STATICS
    Section *st = assembly->get_program()->section(Sections::text);
    if (this->ax == Store)
        throw "can´t store here";
    if (this->ax == Plus)
    {
        DInstruccion *i = new DInstruccion("add");

        i->add_operand(new RegisterOperand(reg->getName()));
        i->add_operand(new RegisterOperand(op_reg->getName()));
        st->add(i);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
incl 0x8(%rdi)
movq 0x10(%rdi), %rax
movq (%rax), %rdi
pushq $0x2
popq %rsi
callq 0xe61c
movq %rax, %rbx
movl 0x38(%r15), %eax
cmpl $0x2, %eax
je 0x1388f
testl %eax, %eax
je 0x13915
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r14
leaq 0x4b5a(%rip), %rsi      # 0x183fb
movq %rax, %rdi
callq 0xdf60
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r12
movq 0x20(%r15), %rdi
callq 0xfa1e
movq %r12, %rdi
movq %rax, %rsi
callq 0xe1b2
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r12
movq 0x28(%r15), %rdi
callq 0xfa1e
movq %r12, %rdi
movq %rax, %rsi
callq 0xe1b2
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd750
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x4ac5(%rip), %rcx      # 0x183e9
movq %rcx, (%rax)
movq 0x11692(%rip), %rsi     # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
jmp 0x1394e
jmp 0x13945
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::BlockStatemntNode*)
void x86_64_linux_generator_visitor::visit(BlockStatemntNode *block)
{
    UPDATE_STATICS
    //cout<<"block load : "<<block->s<<endl;

    vector<ASTU>::iterator x = block->nodos.begin();
    for (; x != block->nodos.end(); x++)
    {
        (*x)->accept(this);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
incl 0x8(%rdi)
movq 0x28(%rsi), %r15
cmpq 0x30(%rbx), %r15
je 0x13c8d
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x13c76
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::AssignStatement*)
void x86_64_linux_generator_visitor::visit(AssignStatement *as)
{
    UPDATE_STATICS

    Section *st = assembly->get_program()->section(Sections::text);
    Register *current_reg = this->reg;
    
    this->ax = Load;
    as->right->accept(this);
    this->ax = Store;
    as->left->accept2(this);
    // rp->free(reg->id);
    this->ax = Load;
    
    this->reg = current_reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rdi
pushq $0x2
popq %rsi
callq 0xe61c
movq 0x20(%rbx), %r15
pushq $0x1
popq %rbp
movl %ebp, 0x38(%rbx)
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
andl $0x0, 0x38(%rbx)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movl %ebp, 0x38(%rbx)
movq %r15, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit2(LEAF::AST::IntConst*)
void x86_64_linux_generator_visitor::visit2(IntConst *number)
{
    UPDATE_STATICS
    Section *st = assembly->get_program()->section(Sections::text);
    if (this->ax == Load)
    {
        DInstruccion *i = new DInstruccion("mov");
        InmediateIntOperand *ops = new InmediateIntOperand(number->value);
        RegisterOperand *opd = new RegisterOperand(this->reg->getName());
        i->add_operand(opd);
        i->add_operand(ops);
        st->add(i);
    }

    if (this->ax == op_types::Plus)
    {
        DInstruccion *i = new DInstruccion("add");
        InmediateIntOperand *ops = new InmediateIntOperand(number->value);
        RegisterOperand *opd = new RegisterOperand(this->reg->getName());
        i->add_operand(opd);
        i->add_operand(ops);
        st->add(i);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
incl 0x8(%rdi)
movq %rsi, %r15
movq 0x10(%rdi), %rax
movq (%rax), %rdi
pushq $0x2
popq %rsi
callq 0xe61c
movq %rax, %rbx
movl 0x38(%r14), %eax
cmpl $0x1, %eax
jne 0x140d0
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r12
leaq 0x439b(%rip), %rsi      # 0x18404
movq %rax, %rdi
callq 0xdf60
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xe17c
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %rbp
movq 0x20(%r14), %rdi
callq 0xfa1e
movq %rbp, %rdi
movq %rax, %rsi
callq 0xe1b2
movq (%r12), %rax
movq %r12, %rdi
movq %rbp, %rsi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd750
movl 0x38(%r14), %eax
cmpl $0x2, %eax
jne 0x1415c
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r12
leaq 0x4310(%rip), %rsi      # 0x183fb
movq %rax, %rdi
callq 0xdf60
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xe17c
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0xfa1e
movq %r15, %rdi
movq %rax, %rsi
callq 0xe1b2
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd750
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1416f
jmp 0x1417a
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r13, %rdi
jmp 0x14199
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r12, %rdi
jmp 0x14199
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
jmp 0x14199
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %rbp, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/backend/x86_64_linux/generator.cpp
// Function: x86_64_linux_generator_visitor::visit(LEAF::AST::FloatConst*)
void x86_64_linux_generator_visitor::visit(FloatConst *number)
{
    UPDATE_STATICS
    if (!number->in_data)
    {
        string *label_data = new string(number->adr_label->c_str());
        label_data->append(" dq ");
        char *chars_val = new char[20];
        sprintf(chars_val, "%.7lf", number->value);
        label_data->append(chars_val);
        assembly->get_program()->section(Sections::data)->add(new RegisterOperand(label_data->c_str()));
        number->in_data = true;
    }
    this->reg = this->rp->reserve_by_size(128);
    number->accept2(this);
    rp->free(this->reg->id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incl 0x8(%rdi)
movq %rsi, %r14
cmpb $0x0, 0x30(%rsi)
jne 0x14258
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r15
movq 0x28(%r14), %rax
movq (%rax), %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x70ae
leaq 0x422e(%rip), %rsi      # 0x1841a
movq %r15, %rdi
callq 0x5460
pushq $0x14
popq %rdi
callq 0x5040
movq %rax, %r12
cvtss2sd 0x24(%r14), %xmm0
leaq 0x4213(%rip), %rsi      # 0x1841f
movq %rax, %rdi
movb $0x1, %al
callq 0x5080
movq %r15, %rdi
movq %r12, %rsi
callq 0x5460
movq 0x10(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0xe61c
movq %rax, %r13
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0xe1b2
movq %r13, %rdi
movq %r12, %rsi
callq 0xd750
movb $0x1, 0x30(%r14)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movl $0x80, %esi
callq *0x78(%rax)
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdi
movl (%rax), %esi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r12, %rdi
jmp 0x142a9
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::draw(std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void ClassHandler::draw(vector<Edge *> *list)
{
    string st("");
    vector<Edge *>::iterator x = list->begin();
    for (; x != list->end(); x++)
    {
        st.append(" ");
        st.append((*x)->nodea->name->c_str());
        if ((*x)->rel == IMPLEMENT)
        {
            st.append(" --> ");
        }
        else
        {
            st.append(" > ");
        }
        st.append((*x)->nodeb->name->c_str());
        st.append(",");
    }
    cout << st << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x2b0f(%rip), %rsi      # 0x17da3
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x70ae
movq (%rbx), %r13
leaq 0x326f(%rip), %rbp      # 0x1851f
leaq 0x326e(%rip), %r15      # 0x18525
leaq 0x2ae6(%rip), %r12      # 0x17da4
cmpq 0x8(%rbx), %r13
je 0x15326
movq %r14, %rdi
leaq 0x1983(%rip), %rsi      # 0x16c51
callq 0x5460
movq (%r13), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5460
movq (%r13), %rax
cmpl $0x1, 0x10(%rax)
movq %r15, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
callq 0x5460
movq (%r13), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x5460
movq %r14, %rdi
movq %r12, %rsi
callq 0x5460
addq $0x8, %r13
jmp 0x152be
movq 0xfca3(%rip), %rdi      # 0x24fd0
leaq 0x8(%rsp), %rsi
callq 0x5200
movq %rax, %rdi
callq 0x5120
leaq 0x8(%rsp), %rdi
callq 0x5488
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1535a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5488
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::implement(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
void ClassHandler::implement(Node *a, Node *b)
{
    if (a->type == CLASS && b->type == INTERFACE)
    {
    }
    else
    {
        if (b->type == CLASS)
        {
            cout << "no puede implementar una clase: " << *a->name << " implement " << *b->name << "(class)" << endl;
        }
        cout << "no puede implementar: " << *a->name << " -> " << *b->name << endl;
        return;
    }
    if (this->check_implement(a, b))
    {
        this->add(new Edge(a, b, IMPLEMENT));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rsi), %ecx
xorl $0x2, %ecx
movl 0x8(%rdx), %eax
movl %eax, %edx
xorl $0x1, %edx
orl %ecx, %edx
jne 0x153d0
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15486
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r12
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15900
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15976
cmpl $0x2, %eax
jne 0x15424
movq 0xfbf4(%rip), %rdi      # 0x24fd0
leaq 0x3146(%rip), %rsi      # 0x18529
callq 0x5240
movq (%r14), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x3150(%rip), %rsi      # 0x1854a
movq %rax, %rdi
callq 0x5240
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x3142(%rip), %rsi      # 0x18556
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0xfba5(%rip), %rdi      # 0x24fd0
leaq 0x312c(%rip), %rsi      # 0x1855e
callq 0x5240
movq (%r14), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x312c(%rip), %rsi      # 0x18575
movq %rax, %rdi
callq 0x5240
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5120
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::check_implement(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
bool ClassHandler::check_implement(Node *a, Node *b)
{

    if (0 == strcmp(a->name->c_str(), b->name->c_str()))
    {
        throw "no se puede implementar asi misma";
    }

    if (this->cyclic(b, a))
    {
        throw "cyclic error (I)";
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdx), %rax
movq (%rax), %rsi
callq 0x5360
testl %eax, %eax
je 0x154c3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15680
testb %al, %al
jne 0x154d4
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x30bb(%rip), %rcx      # 0x1858d
jmp 0x154e3
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x30cc(%rip), %rcx      # 0x185af
movq %rcx, (%rax)
movq 0xfad3(%rip), %rsi      # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::extend(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
void ClassHandler::extend(Node *a, Node *b)
{
    if (a->type == CLASS && b->type == CLASS)
    {
    }
    else
    {
        if (b->type == CLASS)
        {
            cout << "no puede heredar: " << *a->name << " -> " << *b->name << "(class)" << endl;
        }
        cout << "no puede heredar: " << *a->name << " -> " << *b->name << endl;
        return;
    }
    if (this->check_hierarchy(a, b))
    {
        this->add(new Edge(a, b, HIERARCHY));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x2, 0x8(%rsi)
movl 0x8(%rdx), %eax
jne 0x15558
cmpl $0x2, %eax
jne 0x155ac
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1560e
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r12
pushq $0x2
popq %rcx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15900
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15976
cmpl $0x2, %eax
jne 0x155ac
movq 0xfa6c(%rip), %rdi      # 0x24fd0
leaq 0x300f(%rip), %rsi      # 0x1857a
callq 0x5240
movq (%r14), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x2ff3(%rip), %rsi      # 0x18575
movq %rax, %rdi
callq 0x5240
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x2fba(%rip), %rsi      # 0x18556
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5120
movq 0xfa1d(%rip), %rdi      # 0x24fd0
leaq 0x2fc0(%rip), %rsi      # 0x1857a
callq 0x5240
movq (%r14), %rsi
movq %rax, %rdi
callq 0x5200
leaq 0x2fa4(%rip), %rsi      # 0x18575
movq %rax, %rdi
callq 0x5240
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5120
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5420
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/feactures/class/class_handler.cpp
// Function: LEAF::FEACTURE::CLASS::ClassHandler::check_hierarchy(LEAF::HELPER::GRAPH::Node*, LEAF::HELPER::GRAPH::Node*)
bool ClassHandler::check_hierarchy(Node *a, Node *b)
{

    if (0 == strcmp(a->name->c_str(), b->name->c_str()))
    {
        throw "no se puede heredar asi misma";
    }

    if (this->cyclic(b, a))
    {
        throw "cyclic error";
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdx), %rax
movq (%rax), %rsi
callq 0x5360
testl %eax, %eax
je 0x1564b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15680
testb %al, %al
jne 0x1565c
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x2f66(%rip), %rcx      # 0x185c0
jmp 0x1566b
pushq $0x8
popq %rdi
callq 0x5130
leaq 0x2f73(%rip), %rcx      # 0x185de
movq %rcx, (%rax)
movq 0xf94b(%rip), %rsi      # 0x24fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5400
nop