LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::move_right()
void Grid::move_right(){
    if(x + 1 > WIDTH){
        cout << "You can not move to the right" << endl;
    }else{
        if(Map[y][x+1] == 0){
            cout << "This is a non accessible square" << endl;
            return;            
        }
        py = y;
        px = x;
        Map[py][px] = pt;
        x++;
        pt = Map[y][x];
        Map[y][x] = 3;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x78(%rdi), %rcx
cmpq $0x5, %rcx
jl 0xa14d
movq 0x9e91(%rip), %rbx      # 0x13fd0
leaq 0x4924(%rip), %rsi      # 0xea6a
movl $0x1d, %edx
jmp 0xa1b4
movq 0x60(%rdi), %rax
movslq 0x7c(%rdi), %rsi
movq (%rax,%rsi,8), %rdx
cmpl $0x0, 0x4(%rdx,%rcx,4)
je 0xa1a1
movl %esi, 0x84(%rdi)
movl %ecx, 0x80(%rdi)
movl 0x88(%rdi), %esi
movl %esi, (%rdx,%rcx,4)
movslq 0x78(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x78(%rdi)
movslq 0x7c(%rdi), %rdx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax,%rcx,4), %edx
movl %edx, 0x88(%rdi)
movl $0x3, 0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x9e28(%rip), %rbx      # 0x13fd0
leaq 0x4868(%rip), %rsi      # 0xea17
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3100
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::monsters_fainted()
int Grid::monsters_fainted(){
    list<Monster*>::iterator it;
    int count = 0;
    for(it = Monsters.begin(); it != Monsters.end(); ++it){
        if((*it)->get_HealthPower() <= 0){
            count++;
        }
    }

    if(count == Monsters.size()){
        return 1;
    }else{
        return 0;
    }  
        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r15
movq 0x48(%rdi), %r12
xorl %r14d, %r14d
cmpq %r15, %r12
je 0xa836
movq 0x10(%r12), %rdi
callq 0x48d6
xorl %ecx, %ecx
testl %eax, %eax
setle %cl
addl %ecx, %r14d
movq (%r12), %r12
cmpq %r15, %r12
jne 0xa816
movl %r14d, %r14d
xorl %eax, %eax
cmpq %r14, 0x58(%rbx)
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::display_Map()
void Grid::display_Map(){
    for(int k = 0; k < HEIGHT; k++){
        for(int l = 0; l < WIDTH; l++){
            cout << Map[k][l] << "  ";
        }

        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x9763(%rip), %r14      # 0x13fd0
leaq 0x4293(%rip), %r15      # 0xeb07
xorl %r13d, %r13d
movq 0x60(%rbx), %rax
movq (%rax,%r12,8), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x3210
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31c0
incq %r13
cmpq $0x5, %r13
jne 0xa877
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
incq %r12
cmpq $0x5, %r12
jne 0xa874
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Grid.cpp
// Function: Grid::~Grid()
Grid::~Grid(){
    Dragons.clear();
    Exoskeletons.clear();
    Spirits.clear();
    Monsters.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xc3f0
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0xc3f0
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0xc3f0
leaq 0x48(%rbx), %r12
movq %r12, %rdi
callq 0xc3f0
movq 0x48(%rbx), %rdi
cmpq %r12, %rdi
je 0xc38a
movq (%rdi), %r13
movl $0x18, %esi
callq 0x3190
movq %r13, %rdi
cmpq %r12, %r13
jne 0xc375
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xc3a7
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3190
movq %r12, %rdi
cmpq %r15, %r12
jne 0xc392
movq (%r14), %rdi
cmpq %r14, %rdi
je 0xc3c4
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3190
movq %r15, %rdi
cmpq %r14, %r15
jne 0xc3af
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0xc3e1
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %rbx, %r14
jne 0xc3cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::~Squad()
Squad::~Squad(){
    myHeroes.clear();
    Warriors.clear();
    Sorcerers.clear();
    Paladins.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9caa
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x9caa
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x9caa
leaq 0x48(%rbx), %r12
movq %r12, %rdi
callq 0x9caa
movq 0x48(%rbx), %rdi
cmpq %r12, %rdi
je 0xcf88
movq (%rdi), %r13
movl $0x18, %esi
callq 0x3190
movq %r13, %rdi
cmpq %r12, %r13
jne 0xcf73
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xcfa5
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3190
movq %r12, %rdi
cmpq %r15, %r12
jne 0xcf90
movq (%r14), %rdi
cmpq %r14, %rdi
je 0xcfc2
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3190
movq %r15, %rdi
cmpq %r14, %r15
jne 0xcfad
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0xcfdf
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3190
movq %r14, %rdi
cmpq %rbx, %r14
jne 0xcfca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::display_myHeroes()
void Squad::display_myHeroes(){
    list<Hero*>::iterator it;
    for(it = myHeroes.begin(); it != myHeroes.end(); ++it){
        cout << (*it)->get_name() << "\t" << (*it)->get_HealthPower() << "\t" << (*it)->get_MagicPower() 
        << "\t" << (*it)->get_Strength() << "\t" << (*it)->get_Agility() << "\t" << (*it)->get_Dexterity() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
cmpq %rdi, %r14
je 0xda14
movq %rdi, %rbx
movq 0x66ed(%rip), %r15      # 0x13fd0
leaq 0x194a(%rip), %r12      # 0xf234
movq 0x10(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x489e
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31c0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
callq 0x48d6
movq %r13, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
callq 0x4b36
movq %r13, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
callq 0x4b40
movq %r13, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
callq 0x4b4a
movq %r13, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31c0
movq 0x10(%r14), %rdi
callq 0x4b54
movq %r13, %rdi
movl %eax, %esi
callq 0x3210
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xda08
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movq (%r14), %r14
cmpq %rbx, %r14
jne 0xd8ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xda3f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::select_hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Squad::select_hero(string name){
    if(myHeroes.size() == 3){
        cout << "Your Team is full!" << endl;
        return;
    }else{
        Hero* temp;
        string type;
        temp = search_Hero(name);
        if(temp != NULL){
            myHeroes.push_front(temp);
            cout << temp->get_name() << " is now part of your team!" << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
cmpq $0x3, 0x10(%rdi)
jne 0xdaac
movq 0x656b(%rip), %rbx      # 0x13fd0
leaq 0x17f3(%rip), %rsi      # 0xf25f
movl $0x12, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq %rdi, %rbx
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x47b8
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc1c
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xdb08
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3190
testq %r14, %r14
je 0xdba8
movq (%rbx), %r15
movl $0x18, %edi
callq 0x3180
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x10(%rbx)
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x489e
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x6484(%rip), %rdi      # 0x13fd0
callq 0x31c0
movq %rax, %rbx
leaq 0x1717(%rip), %rsi      # 0xf272
movl $0x1a, %edx
movq %rax, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdba8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3190
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xdbbd
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x3190
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdbde
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xdbff
movq -0x50(%rbp), %rsi
jmp 0xdbf7
movq %rax, %rbx
jmp 0xdbff
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdbff
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3190
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xdc14
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x3190
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::search_Hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Hero* Squad::search_Hero(string name){
    list<Hero*>::iterator w;
    for(w = Warriors.begin(); w != Warriors.end(); ++w){
        if((*w)->get_name() == name){
            return *w;
        }
    }

    list<Hero*>::iterator s;
    for(s = Sorcerers.begin(); s != Sorcerers.end(); ++s){
        if((*s)->get_name() == name){
            return *s;
        }
    }

    list <Hero*>::iterator p;
    for(p = Paladins.begin(); p != Paladins.end(); ++p){
        if((*p)->get_name() == name){
            return *p;
        }
    }

    cout << "I could not find this name :(" << endl;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x18(%rdi), %r13
movq %r13, %r14
movq (%r14), %r14
cmpq %r13, %r14
je 0xdca4
movq 0x10(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x489e
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xdc76
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0xdc7f
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x31a0
testl %eax, %eax
sete %r15b
jmp 0xdc82
movq -0x48(%rbp), %r12
xorl %r15d, %r15d
jmp 0xdc82
movb $0x1, %r15b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0xdc9a
movq -0x38(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3190
testb %r15b, %r15b
je 0xdc3b
jmp 0xdd89
movq -0x50(%rbp), %rax
leaq 0x30(%rax), %r14
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0xdd1a
movq 0x10(%r13), %rsi
leaq -0x48(%rbp), %rdi
callq 0x489e
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xdceb
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0xdcf4
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x31a0
testl %eax, %eax
sete %r15b
jmp 0xdcf7
movq -0x48(%rbp), %r12
xorl %r15d, %r15d
jmp 0xdcf7
movb $0x1, %r15b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0xdd0f
movq -0x38(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3190
testb %r15b, %r15b
je 0xdcaf
movq 0x10(%r13), %rax
jmp 0xdd8d
movq -0x50(%rbp), %r14
addq $0x48, %r14
movq %r14, %r15
movq (%r14), %r14
cmpq %r15, %r14
je 0xdd9c
movq 0x10(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x489e
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xdd60
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0xdd69
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x31a0
testl %eax, %eax
sete %r13b
jmp 0xdd6c
movq -0x48(%rbp), %r12
xorl %r13d, %r13d
jmp 0xdd6c
movb $0x1, %r13b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0xdd84
movq -0x38(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3190
testb %r13b, %r13b
je 0xdd25
movq 0x10(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x622d(%rip), %rbx      # 0x13fd0
leaq 0x14e3(%rip), %rsi      # 0xf28d
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x31c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
xorl %eax, %eax
jmp 0xdd8d
// File: /workspace/github_cpp_makefile_star2_O3/kongrigoriou[P]Text-Based-RPG/src/Squad.cpp
// Function: Squad::all_fainted()
int Squad::all_fainted(){
    int count = 0;
    list<Hero*>::iterator it;

    for(it = myHeroes.begin(); it != myHeroes.end(); ++it){
        if((*it)->get_HealthPower() <= 0)
            count++;
    }

    if(count == get_count())
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
xorl %r14d, %r14d
cmpq %rdi, %r15
je 0xde37
movq 0x10(%r15), %rdi
callq 0x48d6
xorl %ecx, %ecx
testl %eax, %eax
setle %cl
addl %ecx, %r14d
movq (%r15), %r15
cmpq %rbx, %r15
jne 0xde1c
xorl %eax, %eax
cmpl 0x10(%rbx), %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/libs/cpptrim.h
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim(std::string & line){
    //If the std::string is empty
    if(line.size() == 0) return;

    //If the string has only one character
    if(line.size() == 1 && !std::isspace(line[0])) return;

    //Left trim
    int first = 0;
    for(unsigned int i = 0; i < line.size(); ++i){
        if (!std::isspace(line[i])){
            first = i;
            break;
        }
    }

    //Right trim
    int last = 0;
    for(unsigned int i = line.size()-1; i >= 0; --i){
        if (!std::isspace(line[i])){
            last = i+1;
            break;
        }
        //--i will break with unsigned int when reaching 0, so we check
        //if i == 0 and, if it is and it's not a space, we break
        if(i == 0){
            last = 0;
            break;
        }
    }

    //Trim the std::string
    line = line.substr(first, last-first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3759
movq %rdi, %rbx
cmpq $0x1, %r14
jne 0x36e3
movq (%rbx), %r15
movsbl (%r15), %edi
callq 0x3050
testl %eax, %eax
jne 0x36e6
jmp 0x3759
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x3050
testl %eax, %eax
je 0x3702
incl %r12d
cmpq %r12, %r14
ja 0x36e9
xorl %r12d, %r12d
leal -0x1(%r14), %eax
addq %rax, %r15
movsbl (%r15), %edi
callq 0x3050
testl %eax, %eax
je 0x3724
decl %r14d
decq %r15
testl %r14d, %r14d
jne 0x3709
xorl %r14d, %r14d
movslq %r12d, %rdx
subl %edx, %r14d
movslq %r14d, %rcx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3759
callq 0x3280
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x377b
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: main
int main(int argc, char** argv)
{
    polaris_setup();
    string file_path = check_args(argc, argv);
    string base_path = join_paths(".", get_working_directory(file_path));
    eval(load_source_file(file_path), base_path);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movl %edi, %r14d
callq 0x39d6
leaq -0x38(%rbp), %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x39fb
leaq -0xa8(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x5d32(%rip), %rsi      # 0x94f1
leaq 0x5d2c(%rip), %rdx      # 0x94f2
leaq -0xb8(%rbp), %rdi
callq 0x7d06
leaq -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x7da4
leaq -0x118(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3d81
leaq -0xd8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0x3beb
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3836
callq 0x3280
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x3847
callq 0x3280
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x3858
callq 0x3280
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x7da4
leaq -0xf8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3f21
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x7da4
leaq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3e24
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x38c4
callq 0x3280
leaq -0xe8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38d9
callq 0x3280
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x38e7
callq 0x3280
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38fc
callq 0x3280
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x390e
callq 0x3280
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x3934
callq 0x3280
jmp 0x3934
movq %rax, %rbx
leaq -0xe8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x394e
callq 0x3280
jmp 0x394e
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x3961
callq 0x3280
jmp 0x3961
movq %rax, %rbx
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x39b2
jmp 0x39bc
movq %rax, %rbx
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3990
callq 0x3280
jmp 0x3990
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x39a6
callq 0x3280
jmp 0x39a6
movq %rax, %rbx
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x39bc
callq 0x3280
jmp 0x39bc
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39ce
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: check_args[abi:cxx11](int, char**)
string check_args(int argc, char** argv)
{
    string filename = "";
    if (argc > 1)
    {
        for (unsigned int i = 1; i < argc; ++i)
        {
            string argument = argv[i];
            if (argument == "-v") display_version(true);
            else if (argument == "-h") display_help();
            else if (argument == "-p") show_pushpops = true;
            else
            {
                filename = argument;
                if (i < argc - 1)
                {
                    warning("some switches after the filename have been ignored.");
                    //TODO these commands should be pushed to the stack.
                }
            }
        }
    }
    if (filename == "")
        error("\nUsage: polaris <file>\nRun polaris -h for more information");
    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movl %esi, %r15d
leaq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, (%rdi)
leaq 0x5971(%rip), %rdx      # 0x9398
movq %rdi, -0x38(%rbp)
movq %rdx, %rsi
callq 0x7d06
cmpl $0x2, %r15d
jl 0x3b26
leal -0x1(%r15), %eax
movq %rax, -0x48(%rbp)
movl %r15d, %ebx
movl $0x1, %r12d
leaq -0x88(%rbp), %r15
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x3120
movq %r15, %rdi
leaq 0x5631(%rip), %rsi      # 0x90a0
callq 0x30d0
testl %eax, %eax
je 0x3af2
movq %r15, %rdi
leaq 0x5621(%rip), %rsi      # 0x90a3
callq 0x30d0
testl %eax, %eax
je 0x3b50
movq %r15, %rdi
leaq 0x560d(%rip), %rsi      # 0x90a6
callq 0x30d0
testl %eax, %eax
je 0x3afe
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x3170
cmpq -0x48(%rbp), %r12
jae 0x3b05
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %r13
movq %r13, %rdi
leaq 0x55df(%rip), %rsi      # 0x90a9
leaq 0x560b(%rip), %rdx      # 0x90dc
callq 0x7d06
movq %r13, %rdi
callq 0x4452
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3b05
callq 0x3280
jmp 0x3b05
movl $0x1, %edi
callq 0x42b9
jmp 0x3b05
movb $0x1, 0x9754(%rip)      # 0xd259
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3b1a
callq 0x3280
incq %r12
cmpq %r12, %rbx
jne 0x3a55
leaq 0x586b(%rip), %rsi      # 0x9398
movq -0x38(%rbp), %rdi
callq 0x30d0
testl %eax, %eax
je 0x3b55
movq -0x38(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x43b1
leaq -0x98(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x5576(%rip), %rsi      # 0x90dd
leaq 0x55a9(%rip), %rdx      # 0x9117
leaq -0xa8(%rbp), %rdi
callq 0x7d06
leaq -0xa8(%rbp), %rdi
callq 0x44b4
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x3bcc
jmp 0x3bd1
jmp 0x3bb4
jmp 0x3bb4
jmp 0x3bb9
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3bbc
callq 0x3280
jmp 0x3bbc
movq %rax, %r14
jmp 0x3bd1
movq %rax, %r14
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3bd1
callq 0x3280
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x3be3
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: join_paths(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string join_paths(string base_path, string new_path)
{
    string joined_path = "";
    if(new_path[0] == '/') //Absolute Path
            joined_path = new_path;
    else if(new_path[0] == '~' && new_path[1] == '/') //Home Path
        joined_path = expand_home(new_path);
    else // Relative path
        joined_path = base_path + "/" + new_path;
    return joined_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x5785(%rip), %rdx      # 0x9398
movq %rdx, %rsi
callq 0x7d06
movq (%r14), %rsi
movzbl (%rsi), %eax
cmpl $0x7e, %eax
je 0x3c3b
cmpl $0x2f, %eax
jne 0x3c98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
jmp 0x3cff
cmpb $0x2f, 0x1(%rsi)
jne 0x3c98
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x7da4
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x41d4
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3170
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c8a
callq 0x3280
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x3cfa
jmp 0x3cff
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7da4
leaq 0x575b(%rip), %rsi      # 0x9415
leaq -0x68(%rbp), %rdi
callq 0x3460
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %r14, %rdx
callq 0x798e
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x3170
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cf1
callq 0x3280
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3cff
callq 0x3280
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d2b
callq 0x3280
jmp 0x3d2b
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0x3d62
jmp 0x3d6c
jmp 0x3d69
jmp 0x3d69
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d59
callq 0x3280
jmp 0x3d59
jmp 0x3d56
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3d6c
callq 0x3280
jmp 0x3d6c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3d79
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: get_working_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string get_working_directory(string base_path)
{
    for(size_t i = base_path.length() - 1; i > 0; i--)
    {
        if(base_path[i] == '/'){
            base_path = base_path.substr(0, i);
            break;
        }
    }
    return base_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
movq %rdx, %rax
cmpq $0x1, %rax
je 0x3de4
movq (%r14), %rsi
leaq -0x1(%rax), %rcx
cmpb $0x2f, -0x1(%rsi,%rax)
movq %rcx, %rax
jne 0x3d9b
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x32d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3170
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3de0
callq 0x3280
movq 0x8(%r14), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7da4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e1c
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: eval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void eval(string source, string base_path)
{
    vector<pair<bool, string> > tokens = tokenize(source);
    for(size_t i = 0; i < tokens.size(); ++i){
        if(tokens[i].first)
            execute_string(tokens[i].second, base_path);
        else
            stack_push(tokens[i].second, false, true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rsi
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x4660
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x3eda
movl $0x8, %r12d
leaq -0x58(%rbp), %r15
xorl %r13d, %r13d
movabsq $-0x3333333333333333, %rbx # imm = 0xCCCCCCCCCCCCCCCD
leaq -0x68(%rbp), %r14
cmpb $0x1, -0x8(%rdi,%r12)
jne 0x3e86
addq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x5073
jmp 0x3ebb
movq %r15, -0x68(%rbp)
movq (%rdi,%r12), %rsi
movq 0x8(%rdi,%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x7da4
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4a94
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ebb
callq 0x3280
incq %r13
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %rbx, %rax
addq $0x28, %r12
cmpq %rax, %r13
jb 0x3e70
leaq -0x48(%rbp), %rdi
callq 0x7ac8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f08
callq 0x3280
jmp 0x3f08
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7ac8
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x7901
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: expand_home(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string expand_home(string filename)
{
    string newPath = "";
    string homeDir = exec("echo $HOME");
    trim(homeDir);
    for(size_t i = 0; i < filename.length(); ++i)
        if(i == 0 && filename[i] == '~' && filename[i+1] == '/')
            newPath += homeDir;
        else
            newPath += filename[i];
    return newPath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x51a1(%rip), %rdx      # 0x9398
movq %rdx, %rsi
callq 0x7d06
leaq 0x5165(%rip), %rsi      # 0x936b
leaq -0x40(%rbp), %rdi
callq 0x45b9
leaq -0x40(%rbp), %rdi
callq 0x36ac
cmpq $0x0, 0x8(%r14)
je 0x425d
xorl %r12d, %r12d
movq (%r14), %rax
testq %r12, %r12
jne 0x4247
cmpb $0x7e, (%rax)
jne 0x4247
cmpb $0x2f, 0x1(%rax)
jne 0x4247
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
jmp 0x4254
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x3250
incq %r12
cmpq 0x8(%r14), %r12
jb 0x4222
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x426f
callq 0x3280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4286
movq %rax, %r14
jmp 0x429b
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x429b
callq 0x3280
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x42a8
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: display_version(bool)
void display_version(bool exit)
{
    cout << endl;
    cout << "  This is Polaris version " << VERSION << endl;
    cout << "  Copyright 2020, Martin del Rio (www.lartu.net)." << endl;
    cout << endl;
    if (exit) polaris_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x8d07(%rip), %r14      # 0xcfd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4e67(%rip), %rsi      # 0x915e
movl $0x1a, %edx
movq %r14, %rdi
callq 0x32f0
leaq 0x4e6e(%rip), %rsi      # 0x9179
movl $0x3, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4e37(%rip), %rsi      # 0x917d
movl $0x31, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
testl %ebx, %ebx
jne 0x43aa
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: display_help()
void display_help()
{
    puts("");
    puts(" Usage:");
    puts("   polaris <source file> [<switch>...]");
    puts(" Switches:");
    puts("   -v              Display Polaris version information.");
    puts("   -h              Display this help.");
    puts("   -p              Show push and pops during execution.");
    puts("");
    puts(" Complete documentation for Polaris should be found on this");
    puts(" system using the 'man polaris' command. If you have access");
    puts(" to the internet, the documentation can also be found online");
    puts(" at www.lartu.net/languages/polaris.");
    puts("");
    polaris_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xa, %edi
callq 0x3330
leaq 0x4de9(%rip), %rdi      # 0x91af
callq 0x3390
leaq 0x4de5(%rip), %rdi      # 0x91b7
callq 0x3390
leaq 0x4e00(%rip), %rdi      # 0x91de
callq 0x3390
leaq 0x4dff(%rip), %rdi      # 0x91e9
callq 0x3390
leaq 0x4e2b(%rip), %rdi      # 0x9221
callq 0x3390
leaq 0x4e45(%rip), %rdi      # 0x9247
callq 0x3390
movl $0xa, %edi
callq 0x3330
leaq 0x4e67(%rip), %rdi      # 0x927f
callq 0x3390
leaq 0x4e97(%rip), %rdi      # 0x92bb
callq 0x3390
leaq 0x4ec7(%rip), %rdi      # 0x92f7
callq 0x3390
leaq 0x4ef8(%rip), %rdi      # 0x9334
callq 0x3390
movl $0xa, %edi
callq 0x3330
xorl %edi, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void error(string message)
{
    cout << "+---------------+" << endl;
    cout << "| Polaris Error |" << endl;
    cout << "+---------------+";
    if (message[0] != '\n') cout << endl << "The error was: ";
    cout << message << endl;
    polaris_exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8b08(%rip), %r14      # 0xcfd0
leaq 0x4c49(%rip), %r15      # 0x9118
movl $0x11, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4c1d(%rip), %rsi      # 0x912a
movl $0x11, %edx
movq %r14, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movl $0x11, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%rbx), %rsi
cmpb $0xa, (%rsi)
je 0x4597
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x4bb5(%rip), %rsi      # 0x913c
movl $0xf, %edx
movq %rax, %rdi
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x8a2e(%rip), %rdi      # 0xcfd0
callq 0x32f0
movq %rax, %rdi
callq 0x3150
movl $0x1, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: exec[abi:cxx11](char const*)
string exec(const char* cmd)
{
    string result = "";
    FILE *fpipe;
    char c = 0;
    if (0 == (fpipe = (FILE*) popen(cmd, "r")))
    {
        perror("popen() failed.");
        polaris_exit(EXIT_FAILURE);
    }
    while (fread(&c, sizeof c, 1, fpipe))
        result += c;
    pclose(fpipe);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x4dbc(%rip), %rdx      # 0x9398
movq %rdx, %rsi
callq 0x7d06
movb $0x0, -0x21(%rbp)
leaq 0x4d6a(%rip), %rsi      # 0x9359
movq %r14, %rdi
callq 0x30f0
testq %rax, %rax
je 0x4643
movq %rax, %r14
leaq -0x21(%rbp), %r15
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3360
testq %rax, %rax
je 0x462b
movsbl -0x21(%rbp), %esi
movq %rbx, %rdi
callq 0x3250
jmp 0x4603
movq %r14, %rdi
callq 0x3340
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3480
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4658
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: stack_push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void stack_push(string token, bool trim_token, bool pushempty)
{
    if (trim_token) trim(token);
    if (token.length() > 0 || pushempty)
    {
        p_stack.push(token);
        if(show_pushpops) cout << "Push: '" << token << "'" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0x4aad
movq %rbx, %rdi
callq 0x36ac
cmpq $0x0, 0x8(%rbx)
sete %al
xorb $0x1, %r14b
testb %r14b, %al
jne 0x4b46
leaq 0x8797(%rip), %rdi      # 0xd260
movq %rbx, %rsi
callq 0x8698
cmpb $0x1, 0x8781(%rip)      # 0xd259
jne 0x4b46
movq 0x84ef(%rip), %r14      # 0xcfd0
leaq 0x48b1(%rip), %rsi      # 0x9399
movl $0x7, %edx
movq %r14, %rdi
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32f0
movq %rax, %rbx
leaq 0x4891(%rip), %rsi      # 0x939f
movl $0x1, %edx
movq %rax, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: stack_pop[abi:cxx11]()
string stack_pop()
{
    string val = "";
    if(p_stack.size() == 0)
    {
        error("cannot pop from an empty stack.");
    }
    else
    {
        val = p_stack.top();
        p_stack.pop();
    }
    if(show_pushpops) cout << "Pop: '" << val << "'" << endl;
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x482d(%rip), %rdx      # 0x9398
movq %rdx, %rsi
callq 0x7d06
movq 0x872e(%rip), %rax      # 0xd2a8
movq %rax, %rdx
subq 0x8704(%rip), %rdx      # 0xd288
shrq $0x3, %rdx
cmpq $0x1, %rax
adcq $-0x1, %rdx
shlq $0x4, %rdx
movq 0x86f5(%rip), %rsi      # 0xd290
movq 0x86f6(%rip), %rcx      # 0xd298
movq %rsi, %rdi
subq %rcx, %rdi
sarq $0x5, %rdi
addq %rdx, %rdi
movq 0x86ca(%rip), %rdx      # 0xd280
subq 0x86b3(%rip), %rdx      # 0xd270
sarq $0x5, %rdx
addq %rdi, %rdx
je 0x4c72
cmpq %rcx, %rsi
jne 0x4bd8
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rax), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x3170
leaq 0x8675(%rip), %rdi      # 0xd260
callq 0x8932
cmpb $0x1, 0x8662(%rip)      # 0xd259
jne 0x4c62
movq 0x83d0(%rip), %rdi      # 0xcfd0
leaq 0x47ba(%rip), %rsi      # 0x93c1
movl $0x6, %edx
callq 0x32f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x83b1(%rip), %rdi      # 0xcfd0
callq 0x32f0
movq %rax, %r14
leaq 0x4771(%rip), %rsi      # 0x939f
movl $0x1, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x471f(%rip), %rsi      # 0x93a1
leaq 0x4737(%rip), %rdx      # 0x93c0
leaq -0x40(%rbp), %rdi
callq 0x7d06
leaq -0x40(%rbp), %rdi
callq 0x44b4
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4cb3
callq 0x3280
jmp 0x4cb3
jmp 0x4cb0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4cc0
callq 0x3280
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: polaris_delay(int)
void polaris_delay(int milliseconds)
{
    struct timespec  req, rem;
    if (milliseconds <= 0L)
        return;
    req.tv_sec = milliseconds / 1000L;
    req.tv_nsec = (milliseconds % 1000L) * 1000000L;
    rem.tv_sec = 0;
    rem.tv_nsec = 0;
    nanosleep(&req, &rem);
}

// Assembly:
testl %edi, %edi
jle 0x4d11
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
leaq -0x20(%rbp), %rax
movq %rcx, (%rax)
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %edi
imull $0xf4240, %edi, %ecx    # imm = 0xF4240
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
leaq -0x10(%rbp), %rsi
movaps %xmm0, (%rsi)
movq %rax, %rdi
callq 0x30e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: num_to_str[abi:cxx11](double)
string num_to_str(pnumber value)
{
    stringstream s;
    s << fixed << value;
    string str = s.str();
    trim(str);
    str.erase(str.find_last_not_of('0') + 1, string::npos);
    str.erase(str.find_last_not_of('.') + 1, string::npos);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
leaq -0x190(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl -0x178(%rbp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, -0x178(%rbp,%rax)
movsd -0x18(%rbp), %xmm0
callq 0x33d0
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x33c0
movq %rbx, %rdi
callq 0x36ac
movq %rbx, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x31b0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x4df9
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x31b0
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x4df9
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4729(%rip), %rdi      # 0x9529
leaq 0x47cd(%rip), %rsi      # 0x95d4
movq %rax, %rdx
xorl %eax, %eax
callq 0x3370
movq %rax, %r14
jmp 0x4e2a
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4e2a
callq 0x3280
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x7901
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: str_is_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool str_is_num(string & source){
    if (source == "inf") return true;
    if (source == "-inf") return true;
    bool already_found_sign = false;
    bool already_found_point = false;
    size_t numbers_before_point = 0;
    size_t numbers_after_point = 0;
    for(size_t i = 0; i < source.length(); ++i)
        if(!already_found_sign && source[i] == '-')
            already_found_sign = true;
        else if(!already_found_point && source[i] == '.')
            already_found_point = true;
        else if(
        source[i] == '0' || source[i] == '1' 
        || source[i] == '2' || source[i] == '3'
        || source[i] == '4' || source[i] == '5'
        || source[i] == '6' || source[i] == '7'
        || source[i] == '8' || source[i] == '9'
        )
        {
            already_found_sign = true;
            if(already_found_point)
                numbers_after_point++;
            else
                numbers_before_point++;
        }
        else
            return false;
    if(numbers_before_point == 0)
        return false;
    if(already_found_point && numbers_after_point == 0)
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x4572(%rip), %rsi      # 0x93c9
callq 0x30d0
movb $0x1, %bl
testl %eax, %eax
je 0x4ef6
leaq 0x455b(%rip), %rsi      # 0x93c8
movq %r14, %rdi
callq 0x30d0
testl %eax, %eax
je 0x4ef6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4ef4
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %ebx, %ebx
xorl %r9d, %r9d
testb $0x1, %r9b
jne 0x4e9f
movb $0x1, %r8b
cmpb $0x2d, (%rcx,%rdx)
je 0x4ed4
movb (%rcx,%rdx), %r8b
testb $0x1, %bl
je 0x4eb7
addb $-0x30, %r8b
cmpb $0xa, %r8b
jae 0x4ef4
incq %rsi
jmp 0x4ed1
cmpb $0x2e, %r8b
jne 0x4ec4
movl %r9d, %r8d
movb $0x1, %bl
jmp 0x4ed4
addb $-0x30, %r8b
cmpb $0xa, %r8b
jae 0x4ef4
incq %rdi
movb $0x1, %r8b
incq %rdx
movl %r8d, %r9d
cmpq %rdx, %rax
jne 0x4e90
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
xorb $0x1, %bl
orb %cl, %bl
andb %al, %bl
jmp 0x4ef6
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]polaris/src/polaris.cpp
// Function: get_var_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void get_var_value(string & var)
{
    if (variables.find(var) == variables.end())
        stack_push("", false, true);
    else
        stack_push(variables[var], false, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8375(%rip), %rdi      # 0xd2b0
movq %rbx, %rsi
callq 0x8d2e
leaq 0x836e(%rip), %rcx      # 0xd2b8
cmpq %rcx, %rax
je 0x4f91
leaq 0x835a(%rip), %rdi      # 0xd2b0
movq %rbx, %rsi
callq 0x7b22
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7da4
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4a94
movq -0x30(%rbp), %rdi
jmp 0x4fc2
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x43f8(%rip), %rdx      # 0x9398
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7d06
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4a94
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4fcc
callq 0x3280
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x4fe5
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4fef
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/examples/echo/server.cpp
// Function: handle_read(int, int, std::shared_ptr<socket>)
void handle_read(int ec, int t, std::shared_ptr<socket> sock){
	if(ec == 0){
		sock->sync_write(buff, t);
		sock->async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
					std::placeholders::_2, sock));
	}
	else{
		std::cerr << "async read error, errno = " << ec << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %edi, %edi
je 0x35d4
movl %edi, %ebx
movq 0xba6c(%rip), %r14      # 0xeff0
leaq 0x5a89(%rip), %rsi      # 0x9014
movl $0x1a, %edx
movq %r14, %rdi
callq 0x3230
movq %r14, %rdi
movl %ebx, %esi
callq 0x3310
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3150
movq %rdx, %r14
movq (%rdx), %rdi
movslq %esi, %rdx
leaq 0xbc1c(%rip), %rsi      # 0xf200
callq 0x5de6
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x360c
movq 0xb9c4(%rip), %rax      # 0xefc0
cmpb $0x0, (%rax)
je 0x3607
incl 0x8(%r14)
jmp 0x360c
lock
incl 0x8(%r14)
movq $0x0, -0x28(%rbp)
movl $0x18, %edi
callq 0x3200
leaq -0xb9(%rip), %rcx       # 0x356c
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
leaq -0x30(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x43e(%rip), %rax       # 0x3a7c
movq %rax, 0x18(%rcx)
leaq 0x445(%rip), %rax       # 0x3a8e
movq %rax, 0x10(%rcx)
leaq 0xbbac(%rip), %rsi      # 0xf200
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
callq 0x6594
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x3678
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x369f
movq %rax, %rbx
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x36b7
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x36b7
movq %rax, %rdi
callq 0x3a01
movq %rax, %rbx
testq %r14, %r14
je 0x36b7
movq %r14, %rdi
callq 0x3a10
movq %rbx, %rdi
callq 0x3330