LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/symb_tab/symbol_table.cpp
// Function: symbol_table::insert(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, Struct*)
Obj *symbol_table::insert(int kind, string *name, Struct *type)
{
    Obj *obj = new Obj(kind, name, type);
    //cout << "; insert st, obj kind: " << kind << ", name " << *name << ", type kind: " << type->kind << ", level: " << curLevel << endl;
    if (type->kind == Struct::Arr) 
    {
       // cout << ";  - elemtype kind: " << type->elemType->kind << endl;
    }

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

        obj->level = curLevel;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x48, %edi
callq 0x5290
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10f64
movq 0x15d9b(%rip), %rax     # 0x26d88
cmpl $0x1, %ebp
jne 0x1102d
addq $0x10, %r14
movl 0x10(%rax), %ecx
movl %ecx, 0x30(%rbx)
incl 0x14(%rax)
leaq 0x15b3a(%rip), %rdi     # 0x26b40
movq %r14, %rsi
callq 0x1176a
movl (%rax), %ecx
movq 0x15d71(%rip), %rax     # 0x26d88
addl %ecx, 0x10(%rax)
movl 0x15d70(%rip), %ecx     # 0x26d90
movl %ecx, 0x34(%rbx)
testl %ecx, %ecx
jne 0x1102d
incl 0x15d53(%rip)           # 0x26d80
addq $0x8, %rax
xorl %ecx, %ecx
movq %rax, %rsi
movq %rcx, %rdx
movq (%rsi), %rcx
leaq 0x20(%rcx), %rsi
testq %rcx, %rcx
jne 0x11036
leaq 0x20(%rdx), %rcx
testq %rdx, %rdx
cmoveq %rax, %rcx
movq %rbx, (%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15cfc(%rip), %r12     # 0x26d88
testq %r12, %r12
je 0x110d3
movq 0x8(%r12), %r14
testq %r14, %r14
je 0x110cd
movq 0x8(%rbx), %r15
movq 0x8(%r14), %rax
cmpq %r15, 0x8(%rax)
jne 0x110c4
testq %r15, %r15
je 0x11142
movq (%rbx), %rsi
movq (%rax), %rdi
movq %r15, %rdx
callq 0x52b0
testl %eax, %eax
je 0x11142
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x1109f
movq (%r12), %r12
jmp 0x1108c
movq 0x14efe(%rip), %r14     # 0x25fd8
leaq 0x8bfb(%rip), %rsi      # 0x19cdc
movl $0x2, %edx
movq %r14, %rdi
callq 0x5300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x9f07(%rip), %rsi      # 0x1b00e
movl $0xe, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x15cc6(%rip), %r14     # 0x26e08
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %r14
testq %r14, %r14
je 0x11195
movq 0x8(%rbx), %r15
movq 0x8(%r14), %rax
cmpq %r15, 0x8(%rax)
jne 0x1118c
testq %r15, %r15
je 0x11204
movq (%rbx), %rsi
movq (%rax), %rdi
movq %r15, %rdx
callq 0x52b0
testl %eax, %eax
je 0x11204
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x11167
movq 0x14e3c(%rip), %r14     # 0x25fd8
leaq 0x8b39(%rip), %rsi      # 0x19cdc
movl $0x2, %edx
movq %r14, %rdi
callq 0x5300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x9e3f(%rip), %rsi      # 0x1b008
movl $0x14, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x15c04(%rip), %r14     # 0x26e08
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x20, %edi
callq 0x5290
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x8, 0x10(%rax)
movl 0x15b60(%rip), %ecx     # 0x26d90
movl %ecx, 0x18(%rax)
movq 0x15b4e(%rip), %rdx     # 0x26d88
movq %rdx, (%rax)
movq %rax, 0x15b44(%rip)     # 0x26d88
incl %ecx
movl %ecx, 0x15b44(%rip)     # 0x26d90
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x9725(%rip), %rsi      # 0x1b045
leaq 0x9728(%rip), %rdx      # 0x1b04f
movq %rbx, %rdi
callq 0x8496
leaq 0x971a(%rip), %rsi      # 0x1b050
movq %rbx, %rdi
callq 0x54b0
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x54b0
leaq 0x9703(%rip), %rsi      # 0x1b057
movq %rbx, %rdi
callq 0x54b0
movl 0x10(%r14), %r12d
movl %r12d, %ebp
negl %ebp
cmovsl %r12d, %ebp
movl $0x1, %r14d
cmpl $0xa, %ebp
jb 0x119bd
movl $0x4, %r14d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x119b4
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x119ba
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x119bd
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r14d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x11981
addl $-0x3, %r14d
jmp 0x119bd
addl $-0x2, %r14d
jmp 0x119bd
decl %r14d
shrl $0x1f, %r12d
movl %r12d, %esi
addl %r14d, %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x2d, %edx
callq 0x5310
movq (%r15), %rdi
addq %r12, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x7d64
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x50f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11a18
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
leaq 0x9640(%rip), %rsi      # 0x1b05f
movq %rbx, %rdi
callq 0x54b0
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11a60
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x11a5b
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/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
cmpl $0x0, (%rdi)
jle 0x11b1d
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
cmpl %ebp, %eax
je 0x11b42
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x11afd
movl $0x8, %edi
callq 0x5140
leaq 0x9533(%rip), %rcx      # 0x1b061
movq %rcx, (%rax)
movq 0x14490(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
cmpq 0x10(%rdi), %r14
je 0x11e83
xorl %r15d, %r15d
movabsq $0x100000000, %r12      # imm = 0x100000000
movq (%r14), %rax
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testb %al, %al
jne 0x11e76
movq (%r14), %rax
movl 0x10(%rax), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x88(%rax)
cmpl %eax, %ebp
jne 0x11e76
movq (%r14), %rax
cmpb $0x0, 0x20(%rax)
jne 0x11ec3
addq $0x8, %r14
addq %r12, %r15
cmpq 0x10(%rbx), %r14
jne 0x11e46
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq %rax, %r14
testq %rax, %rax
je 0x11ed6
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x121d6
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x1248c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
sarq $0x1d, %r15
movq (%rax,%r15), %r14
testq %r14, %r14
jne 0x11e94
jmp 0x11e83
movl $0x8, %edi
callq 0x5140
leaq 0x91bb(%rip), %rcx      # 0x1b0a2
movq %rcx, (%rax)
movq 0x140d7(%rip), %rsi     # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11a82
movq %rax, %rdi
movl $0x40, %esi
callq 0x11aec
movq %rax, %r14
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r12
movl $0xc, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
movl $0x80, %esi
callq *0x78(%rax)
movl (%rax), %esi
movq %r15, %rdi
callq 0x1085a
addq $0x8, %r12
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r12, %rdi
callq 0x15bc4
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r12
movl $0xc, %edi
callq 0x5290
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
movl $0x20, %esi
callq *0x78(%rax)
movl (%rax), %esi
movq %r15, %rdi
callq 0x1085a
addq $0x8, %r12
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r12, %rdi
callq 0x15bc4
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
movl $0xc, %edi
callq 0x5290
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x10882
addq $0x8, %r15
movq %rsp, %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0x15bc4
movq 0x28(%rbx), %rax
movq 0x8(%rax), %r15
movl $0xc, %edi
callq 0x5290
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x10882
addq $0x8, %r15
movq %rsp, %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0x15bc4
movq 0x10dcf(%rip), %r14     # 0x25fd8
leaq 0x5fe0(%rip), %rsi      # 0x1b1f0
movl $0x9, %edx
movq %r14, %rdi
callq 0x5300
movq 0x50(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x5fc0(%rip), %rsi      # 0x1b1fa
movl $0x2, %edx
movq %rax, %rdi
callq 0x5300
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x108a4
testq %rax, %rax
je 0x15274
movq %rax, %rbx
movq %rax, %rdi
callq 0x5120
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x5300
jmp 0x1528e
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x5440
leaq 0x5f66(%rip), %rsi      # 0x1b1fb
movl $0x1, %edx
movq %r14, %rdi
callq 0x5300
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x152d7
movq %rax, %rbx
movl $0xc, %esi
movq %r14, %rdi
jmp 0x152f1
jmp 0x152e6
movq %rax, %rbx
movl $0xc, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x48(%rdi)
jle 0x153f0
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x10c44(%rip), %r14     # 0x25fd8
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x28(%rax)
jne 0x153df
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r14, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
incq %r15
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jl 0x15394
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x2, %esi
callq 0x10346
movq %rax, %rbx
movl 0x38(%r15), %eax
cmpl $0x2, %eax
je 0x16121
testl %eax, %eax
je 0x161ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x5290
movq %rax, %r14
leaq 0x52a6(%rip), %rsi      # 0x1b3db
movq %rax, %rdi
callq 0xfc44
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq 0x20(%r15), %rdi
callq 0x118ec
movq %r12, %rdi
movq %rax, %rsi
callq 0xfe82
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq 0x28(%r15), %rdi
callq 0x118ec
movq %r12, %rdi
movq %rax, %rsi
callq 0xfe82
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 0xf294
movl $0x8, %edi
callq 0x5140
leaq 0x520b(%rip), %rcx      # 0x1b3c9
movq %rcx, (%rax)
movq 0xfe00(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
jmp 0x161ec
jmp 0x161e1
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
incl 0x8(%rdi)
movq 0x28(%rsi), %r15
cmpq 0x30(%rsi), %r15
je 0x16561
movq %rdi, %rbx
movq %rsi, %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
cmpq 0x30(%r14), %r15
jne 0x1654c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x2, %esi
callq 0x10346
movq %rax, %rbx
movl 0x38(%r14), %eax
cmpl $0x1, %eax
jne 0x169e2
movl $0x28, %edi
callq 0x5290
movq %rax, %r12
leaq 0x4a6d(%rip), %rsi      # 0x1b3e4
movq %rax, %rdi
callq 0xfc44
movl $0x10, %edi
callq 0x5290
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xfe48
movl $0x10, %edi
callq 0x5290
movq %rax, %rbp
movq 0x20(%r14), %rdi
callq 0x118ec
movq %rbp, %rdi
movq %rax, %rsi
callq 0xfe82
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 0xf294
movl 0x38(%r14), %eax
cmpl $0x2, %eax
jne 0x16a74
movl $0x28, %edi
callq 0x5290
movq %rax, %r12
leaq 0x49dc(%rip), %rsi      # 0x1b3db
movq %rax, %rdi
callq 0xfc44
movl $0x10, %edi
callq 0x5290
movq %rax, %r13
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0xfe48
movl $0x10, %edi
callq 0x5290
movq %rax, %r15
movq 0x20(%r14), %rdi
callq 0x118ec
movq %r15, %rdi
movq %rax, %rsi
callq 0xfe82
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 0xf294
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16a87
jmp 0x16a94
movq %rax, %rbx
movl $0x10, %esi
movq %r13, %rdi
jmp 0x16ab9
movq %rax, %rbx
movl $0x28, %esi
movq %r12, %rdi
jmp 0x16ab9
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x16ab9
movq %rax, %rbx
movl $0x10, %esi
movq %rbp, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16b7e
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
movq 0x28(%r14), %rax
movq (%rax), %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xeba0
leaq 0x48ec(%rip), %rsi      # 0x1b3fa
movq %r15, %rdi
callq 0x54b0
movl $0x14, %edi
callq 0x5040
movq %rax, %r12
cvtss2sd 0x24(%r14), %xmm0
leaq 0x48cf(%rip), %rsi      # 0x1b3ff
movq %rax, %rdi
movb $0x1, %al
callq 0x5090
movq %r15, %rdi
movq %r12, %rsi
callq 0x54b0
movq 0x10(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x10346
movq %rax, %r13
movl $0x10, %edi
callq 0x5290
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0xfe82
movq %r13, %rdi
movq %r12, %rsi
callq 0xf294
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
movl $0x10, %esi
movq %r12, %rdi
jmp 0x16bd3
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x30d2(%rip), %rdx      # 0x1ad8b
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x8496
movq (%rbx), %rbp
cmpq 0x8(%rbx), %rbp
je 0x17d53
leaq 0x8(%rsp), %r15
leaq 0x3820(%rip), %r13      # 0x1b4ff
leaq 0x381f(%rip), %r14      # 0x1b505
leaq 0x309f(%rip), %r12      # 0x1ad8c
movq %r15, %rdi
leaq 0x1f4a(%rip), %rsi      # 0x19c41
callq 0x54b0
movq (%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x54b0
movq (%rbp), %rax
cmpl $0x1, 0x10(%rax)
movq %r14, %rsi
cmoveq %r13, %rsi
movq %r15, %rdi
callq 0x54b0
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x54b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x54b0
addq $0x8, %rbp
cmpq 0x8(%rbx), %rbp
jne 0x17ced
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xe274(%rip), %rdi      # 0x25fd8
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17daf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17dc0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17ddf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17e4c
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17f8c
movl $0x18, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x18598
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18626
cmpl $0x2, %eax
jne 0x17ee9
movq 0xe17c(%rip), %r15      # 0x25fd8
leaq 0x36a6(%rip), %rsi      # 0x1b509
movl $0x20, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x369e(%rip), %rsi      # 0x1b52a
movl $0xb, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x3681(%rip), %rsi      # 0x1b536
movl $0x7, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0xe0e8(%rip), %r15      # 0x25fd8
leaq 0x3647(%rip), %rsi      # 0x1b53e
movl $0x16, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x3635(%rip), %rsi      # 0x1b555
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51a0
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 0x53a0
testl %eax, %eax
je 0x17fc9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1821c
testb %al, %al
jne 0x17fdc
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x5140
leaq 0x3593(%rip), %rcx      # 0x1b56d
jmp 0x17fed
movl $0x8, %edi
callq 0x5140
leaq 0x35a2(%rip), %rcx      # 0x1b58f
movq %rcx, (%rax)
movq 0xdfd1(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18066
cmpl $0x2, %eax
jne 0x18103
movq %rdi, %r15
movq %r14, %rsi
movq %rbx, %rdx
callq 0x181a6
movl $0x18, %edi
callq 0x5290
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x18598
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18626
cmpl $0x2, %eax
jne 0x18103
movq 0xdf62(%rip), %r15      # 0x25fd8
leaq 0x34dd(%rip), %rsi      # 0x1b55a
movl $0x12, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x34af(%rip), %rsi      # 0x1b555
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r15
leaq 0x3467(%rip), %rsi      # 0x1b536
movl $0x7, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0xdece(%rip), %r15      # 0x25fd8
leaq 0x3449(%rip), %rsi      # 0x1b55a
movl $0x12, %edx
movq %r15, %rdi
callq 0x5300
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x5300
movq %rax, %r14
leaq 0x341b(%rip), %rsi      # 0x1b555
movl $0x4, %edx
movq %rax, %rdi
callq 0x5300
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x5300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51a0
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/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 0x53a0
testl %eax, %eax
je 0x181e3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1821c
testb %al, %al
jne 0x181f6
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x5140
leaq 0x33ac(%rip), %rcx      # 0x1b5a0
jmp 0x18207
movl $0x8, %edi
callq 0x5140
leaq 0x33b7(%rip), %rcx      # 0x1b5be
movq %rcx, (%rax)
movq 0xddb7(%rip), %rsi      # 0x25fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::filter_path_from_by_nodea(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
vector<Edge *> *Graph::filter_path_from_by_nodea(Node *n, vector<Edge *> *list)
{
    vector<Edge *> *rf = new vector<Edge *>;
    vector<Edge *>::iterator x = list->begin();
    for (; x != list->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), n->name->c_str()))
        {
            rf->push_back((*x));
        }
    }

    return rf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x5290
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x18619
movq (%r12), %r13
movq (%r13), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
jne 0x18613
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x18608
movq %r13, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x18613
movq %r15, %rdi
movq %r12, %rdx
callq 0x1871a
addq $0x8, %r12
jmp 0x185d1
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::path_from(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void Graph::path_from(Node *a, vector<Edge *> *r)
{

    vector<Edge *>::iterator x = edges->begin();
    for (; x != edges->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), a->name->c_str()))
        {

            r->push_back((*x));
            path_from((*x)->nodeb, r);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
movq (%r13), %r12
cmpq 0x8(%r13), %r12
je 0x186cd
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%r12), %rbp
movq (%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x53a0
testl %eax, %eax
jne 0x186c3
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x186a2
movq %rbp, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x186ad
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1871a
movq (%r12), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x18650
movq (%r15), %r13
addq $0x8, %r12
cmpq 0x8(%r13), %r12
jne 0x18671
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/make_shared.cc
// Function: main
int main(int argc, char const *argv[])
{
	auto num = cplusplus_primer::make_shared<int>(42);
	std::cout << *num << std::endl;

	// basic_string(size_type count, CharT ch, const Allocator& alloc = Allocator());
	auto str = cplusplus_primer::make_shared<std::string>(10, 'c');
	std::cout << *str << std::endl;

	auto foo = cplusplus_primer::make_shared<Foo>(99);
	std::cout << foo->bar << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x18, %edi
callq 0x1070
movq %rax, %rbx
movabsq $0x100000001, %r15      # imm = 0x100000001
movq %r15, 0x8(%rax)
leaq 0x2a4d(%rip), %rax      # 0x3ca8
movq %rax, (%rbx)
movl $0x2a, 0x10(%rbx)
movq 0x2d6c(%rip), %rdi      # 0x3fd8
movl $0x2a, %esi
callq 0x10d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq -0x34(%rbp), %rcx
movl $0xa, (%rcx)
leaq -0x19(%rbp), %r8
movb $0x63, (%r8)
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x1a(%rbp), %rdx
callq 0x14ae
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x2cfb(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x18, %edi
callq 0x1070
movq %rax, %r14
movq %r15, 0x8(%rax)
leaq 0x2a4c(%rip), %rax      # 0x3d70
movq %rax, (%r14)
movl $0x63, 0x10(%r14)
movq 0x2ca2(%rip), %rdi      # 0x3fd8
movl $0x63, %esi
callq 0x10d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x13cc
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x1380
callq 0x13cc
movq %rbx, %rdi
callq 0x13cc
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a6
jmp 0x13b9
movq %rax, %r15
movq %r14, %rdi
callq 0x13cc
jmp 0x13a9
movq %rax, %r15
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x13bc
callq 0x13cc
jmp 0x13bc
movq %rax, %r15
movq %rbx, %rdi
callq 0x13cc
movq %r15, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: main
int main(){
    bench(bench_lock);
    bench(bench_lock_guard);
    bench(bench_atomic);

    return 0;
}

// Assembly:
pushq %rax
callq 0x2349
callq 0x24f8
callq 0x26d0
callq 0x28a3
callq 0x2a76
callq 0x2c49
callq 0x2e1c
callq 0x2fef
callq 0x31c2
callq 0x3371
callq 0x3549
callq 0x371c
callq 0x38ef
callq 0x3ac2
callq 0x3c95
callq 0x3e68
callq 0x403b
callq 0x41c6
callq 0x4378
callq 0x4525
callq 0x46d2
callq 0x487f
callq 0x4a2c
callq 0x4bd9
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: void bench_atomic<1>()
void bench_atomic(){
    std::mutex mutex;
    unsigned long throughput = 0;

    for(int i = 0; i < REPEAT; ++i){
        std::atomic<int> counter;
        counter.store(0);

        std::vector<std::thread> threads;

        Clock::time_point t0 = Clock::now();

        for(int i = 0; i < Threads; ++i){
            threads.push_back(std::thread([&](){
                for(int i = 0; i < OPERATIONS; ++i){
                    ++counter;
                }
            }));
        }

        for(auto& thread : threads){
            thread.join();
        }

        Clock::time_point t1 = Clock::now();

        milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);
        throughput += (Threads * OPERATIONS) / ms.count();
    }
    std::cout << "atomic with " << Threads << " threads throughput = " << (throughput / REPEAT) << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %r12
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %eax, %eax
xchgl %eax, 0x4(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
callq 0x2040
leaq 0x4(%rsp), %rcx
movq %rax, %r13
movq %rcx, 0x30(%rsp)
leaq 0x8(%rsp), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x5b62
movq %r12, %rdi
movq %r14, %rsi
callq 0x4e2a
cmpq $0x0, 0x8(%rsp)
jne 0x41ac
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r14
cmpq %r14, %rbp
je 0x40c4
movq %rbp, %rdi
callq 0x2160
addq $0x8, %rbp
jmp 0x40b1
callq 0x2040
subq %r13, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r12, %rdi
imulq %rcx
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rcx
xorl %edx, %edx
addq %rax, %rcx
movl $0x3d090, %eax          # imm = 0x3D090
idivq %rcx
addq %rax, %rbx
callq 0x4df6
incl %r15d
cmpl $0x5, %r15d
jne 0x4053
movq 0x6ec5(%rip), %r14      # 0xafd8
leaq 0x2f53(%rip), %rsi      # 0x706d
movl $0xc, %edx
movq %r14, %rdi
callq 0x2130
movl $0x1, %esi
movq %r14, %rdi
callq 0x2170
leaq 0x2ef0(%rip), %rsi      # 0x702b
movl $0x16, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x2130
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rdx
movq %r14, %rdi
mulxq %rax, %rsi, %rsi
shrq $0x2, %rsi
callq 0x20a0
movq %rax, %rbx
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41b1
cmpq $0x0, 0x8(%rsp)
je 0x41b1
callq 0x2050
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x4df6
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int tss_help(std::string name)
{
    std::cout << "Tom's simple shell\n"
              << "These shell commands are defined internally. Type 'help' to see this list.\n"
              << "Type 'help name' to find out more about the function 'name'.\n"
              << "The following are built in: "
              << tss_get()
              << std::endl;
    /// \todo Help for individual commands
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x4919(%rip), %rbx      # 0x6fc0
leaq 0x195b(%rip), %rsi      # 0x4009
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x195b(%rip), %rsi      # 0x401d
movl $0x4b, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x1993(%rip), %rsi      # 0x4069
movl $0x3d, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x19bd(%rip), %rsi      # 0x40a7
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x21b0
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2787
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2755
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2180
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x277f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_get[abi:cxx11]()
std::string tss_get()
{
    std::string str;
    for(auto elem : funcMap)
        str.append("\n " + elem.first);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x49ef(%rip), %r14      # 0x71a8
leaq 0x49d8(%rip), %rax      # 0x7198
cmpq %rax, %r14
je 0x286c
leaq -0x70(%rbp), %r15
leaq -0x90(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq 0x20(%r14), %rsi
movq %r12, %rdi
callq 0x30fe
movq %r13, %rdi
leaq 0x18de(%rip), %rsi      # 0x40cc
movq %r12, %rdx
callq 0x315d
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x281f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x2835
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x2851
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2110
movq %rax, %r14
leaq 0x4935(%rip), %rax      # 0x7198
cmpq %rax, %r14
jne 0x27d8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x32ad
movq %rax, %r14
jmp 0x28b8
movq %rax, %r14
jmp 0x28ac
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x28ac
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2180
leaq -0x90(%rbp), %rdi
callq 0x3026
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x28d0
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/frainfreeze[P]tss/./shell.h
// Function: shell::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string exec(std::string cmd) {
    // http://man7.org/linux/man-pages/man3/popen.3.html
    std::array<char, 128> buffer;
    std::string result;
    std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);

    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    
    while (!feof(pipe.get())) {
        if (fgets(buffer.data(), 128, pipe.get()) != nullptr)
            result += buffer.data();
    }
    
    return result;
    /// \todo Ignores stderr
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rdi
leaq 0x179c(%rip), %rsi      # 0x40d4
callq 0x2090
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq 0x467c(%rip), %rdx      # 0x6fc8
movq %rax, %rsi
callq 0x390a
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x29bc
callq 0x2220
testl %eax, %eax
jne 0x299b
leaq -0xb0(%rbp), %r14
movq -0x30(%rbp), %rdx
movq %r14, %rdi
movl $0x80, %esi
callq 0x2240
testq %rax, %rax
je 0x298e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22c0
movq -0x30(%rbp), %rdi
callq 0x2220
testl %eax, %eax
je 0x296d
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x29a9
callq 0x349e
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r15
leaq 0x1706(%rip), %rsi      # 0x40d6
movq %rax, %rdi
callq 0x20c0
movq 0x4611(%rip), %rsi      # 0x6ff0
movq 0x45ca(%rip), %rdx      # 0x6fb0
movq %r15, %rdi
callq 0x2260
jmp 0x2a02
movq %rax, %r14
movq %r15, %rdi
callq 0x2130
jmp 0x2a05
movq %rax, %r14
jmp 0x2a13
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2a13
callq 0x349e
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2a27
movq (%r12), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-circular_queue/tests/pingpong.cpp
// Function: main
int
main()
{
	try
	{
		run();
	}
	catch (const std::exception& ex)
	{
		std::cerr << ex.what() << std::endl;
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbx
callq 0x24bc
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x29a2
movq %rbx, %rdi
callq 0x20b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x4668(%rip), %rdi      # 0x6fe8
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x21e0
movq %rax, %rbx
callq 0x2250
movq %rbx, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x2bbf