LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/task.cpp
// Function: Task::parse()
Task Task::parse()
{
    for (unsigned i = 0; i < name.size() - 1; i++){
        if (name.substr(name.size() - i - 1, 1) == ":"){
            if (name.substr(name.size() - i, 1) == "1"){
                complete = true;
            }
            
            name = name.substr(0, name.size() - i - 1);
            return *this;
        }
    }
    
    return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rsi), %rdx
cmpq $0x1, %rdx
setne %bl
je 0x8b8c
movl $0x1, %r13d
xorl %r15d, %r15d
movq %r15, %r12
notq %r12
addq %r12, %rdx
movl $0x1, %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x32c0
movq %rbp, %rdi
leaq 0x3aba(%rip), %rsi      # 0xc609
callq 0x30f0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8b72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
testl %ebp, %ebp
je 0x8bc3
movl %r13d, %r15d
movq 0x8(%r14), %rdx
leaq -0x1(%rdx), %rax
incl %r13d
cmpq %r15, %rax
seta %bl
ja 0x8b27
movq (%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x5cbc
movb 0x20(%r14), %al
movb %al, 0x20(%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
subq %r15, %rdx
leaq 0x8(%rsp), %r15
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x3420(%rip), %rsi      # 0xc006
movq %r15, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8c0a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
testl %ebp, %ebp
jne 0x8c13
movb $0x1, 0x20(%r14)
addq 0x8(%r14), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x32c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3360
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8c51
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq (%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x5cbc
movb 0x20(%r14), %al
movb %al, 0x20(%r15)
testb $0x1, %bl
je 0x8b90
jmp 0x8bb1
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/todo.cpp
// Function: main
int main(int argv, char **argc)
{
    if (parseArgs(argv, argc)){
        return EXIT_NORMAL;
    }
  
    Draw::init(); 
    Core::init();

    TodoList *todoList = Core::list(name());
    unsigned position = 0;

    while(true){
        Draw::draw(todoList, position);
        if (Core::handleInput(getch(), todoList, position)){
            break;
        }
    }

    Draw::stop();
    Core::stop();

    todoList->save();
    delete todoList;

    return EXIT_NORMAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
callq 0x445c
testb %al, %al
jne 0x8e17
callq 0x6ba8
callq 0x6020
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x59d8
movq %rbx, %rdi
callq 0x605f
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8da7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rsp, %rbx
movq %r14, (%rbx)
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
movq 0x7208(%rip), %r15      # 0xffc8
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x6fd8
movq (%r15), %rdi
callq 0x3140
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x60fc
testb %al, %al
je 0x8dc0
callq 0x87d8
callq 0x603a
movq (%rsp), %rdi
callq 0x8f8a
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x8e17
movq %rbx, %rdi
callq 0x8f3e
movl $0x28, %esi
movq %rbx, %rdi
callq 0x32b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e41
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::save()
void TodoList::save()
{
    mkdir(getSaveDir().c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
    std::ofstream file(getPath());

    if (!file.good()){
        std::cout << "failed to write to-do list!\n";
        return;
    }

    for (unsigned i = 0; i < size(); i++){
        file << at(i).save() << "\n";
    }

    file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x9170
movq (%r14), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x3180
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x8fd2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x92c6
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x3570
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x900f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x903c
movq 0x6faa(%rip), %rdi      # 0xffd0
leaq 0x3627(%rip), %rsi      # 0xc654
movl $0x1c, %edx
callq 0x3310
jmp 0x90d9
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
je 0x90cf
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x307b(%rip), %r12      # 0xc0e2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9608
movq %r14, %rdi
movq %rax, %rsi
callq 0x8a12
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3310
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x90b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
incl %ebp
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %eax # imm = 0xCCCCCCCD
cmpl %eax, %ebp
jb 0x9067
leaq 0x28(%rsp), %rdi
callq 0x33b0
movq 0x6ee0(%rip), %rax      # 0xffc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x3260
leaq 0x120(%rsp), %rdi
callq 0x3120
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x913f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9168
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0x9168
movq %rax, %rbx
jmp 0x915e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x915e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x28(%rsp), %rdi
callq 0x33d0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::remove(unsigned int)
void TodoList::remove(unsigned position)
{
    if (taskList->size() > position){
        taskList->erase(taskList->begin() + position);
    }
    if (autoSave){
        save();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
movl %esi, %ecx
cmpq %rcx, %rdx
jbe 0x9e83
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rsi
callq 0xa79c
movq %rbx, %rdi
popq %rbx
jmp 0x8f8a
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::swap(unsigned int)
bool TodoList::swap(unsigned pos)
{
    if (pos >= size() - 1){
        return false; 
    }
    Task temp = taskList->at(pos);
    taskList->at(pos) = taskList->at(pos + 1);
    taskList->at(pos + 1) = temp;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r13d
movq (%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %ebp # imm = 0xCCCCCCCD
decl %ebp
cmpl %esi, %ebp
jbe 0x9fd7
movl %r13d, %r15d
movq (%rax), %rbx
movq 0x8(%rax), %rdx
subq %rbx, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq %r15, %rdx
jbe 0x9fec
movq %rdi, %r14
leaq (%r15,%r15,4), %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx,%r12,8), %rsi
movq 0x8(%rbx,%r12,8), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5cbc
movb 0x20(%rbx,%r12,8), %al
leaq 0x8(%rsp), %rcx
movb %al, 0x20(%rcx)
movq (%r14), %rcx
movq %r13, 0x30(%rsp)
incl %r13d
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %r13, %rdx
jbe 0x9ffd
cmpq %r15, %rdx
jbe 0xa000
leaq (,%r13,4), %rbx
addq %r13, %rbx
leaq (%rax,%rbx,8), %r15
leaq (%rax,%r12,8), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31b0
movb 0x20(%r15), %al
movb %al, 0x20(%r12)
movq (%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
movq %r13, %r15
cmpq %r13, %rdx
jbe 0xa000
leaq (%rax,%rbx,8), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x31b0
movb 0x28(%rsp), %al
movb %al, 0x20(%r14)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9fd2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x30(%rsp), %r13
cmpl %r13d, %ebp
seta %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23f5(%rip), %rdi      # 0xc3e8
movq %r15, %rsi
xorl %eax, %eax
callq 0x3410
movq %r13, %r15
leaq 0x23e1(%rip), %rdi      # 0xc3e8
movq %r15, %rsi
xorl %eax, %eax
callq 0x3410
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa030
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/todolist.cpp
// Function: TodoList::sort()
void TodoList::sort()
{
    unsigned pos = 0;
    for (unsigned i = 0; i < size(); i++){
        if (taskList->at(i).div()){
            std::sort(taskList->begin() + pos, taskList->begin() + i,
                      Task::cmp);
            pos = i + 1;
        } else if (i == size() - 1){
            std::sort(taskList->begin() + pos, taskList->end(),
                      Task::cmp);
            pos = i + 1;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
imulq %rbp, %rdx
testl %edx, %edx
je 0xa166
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq %r14, %rdx
jbe 0xa175
addq %r15, %rdi
callq 0x8ca6
testb %al, %al
je 0xa0c4
cmpl %r13d, %r14d
je 0xa13d
movl %r13d, %eax
movq (%rbx), %rcx
movq (%rcx), %r12
leaq (%rax,%rax,4), %rcx
leaq (%r12,%rcx,8), %r13
addq %r15, %r12
shlq $0x3, %rax
leaq (%rax,%rax,4), %rax
movq %r15, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
bsrq %rcx, %rdx
jmp 0xa107
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r12
movq %r12, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
decl %ecx
cmpl %ecx, %r14d
jne 0xa141
movl %r13d, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %r12, %r13
je 0xa13d
movq %r12, %rax
subq %r13, %rax
sarq $0x3, %rax
imulq %rbp, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r12, %rsi
leaq -0x13e9(%rip), %rbp     # 0x8d34
movq %rbp, %rcx
callq 0xa831
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
callq 0xa924
leal 0x1(%r14), %r13d
incq %r14
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
addq $0x28, %r15
cmpl %edx, %r14d
jb 0xa076
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x226c(%rip), %rdi      # 0xc3e8
movq %r14, %rsi
xorl %eax, %eax
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/win.cpp
// Function: Win::Win(unsigned int, unsigned int, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Win::Win(unsigned x, unsigned y, unsigned w, unsigned h, 
         string name, bool border)
{
    this->x = x;
    this->y = y;
    this->width = width;
    this->height = height;

    this->name = name;

    this->border = newwin(h, w, y, x); 
    
    if (border)
        win = newwin(h - 2, w - 2, y + 1, x + 1);
    else
        win = newwin(h, w, y, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movq %rbx, %rdi
movq %r9, %rsi
callq 0x31b0
movl %ebp, %edi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
callq 0x32d0
movb 0x40(%rsp), %cl
movq %rax, 0x8(%r14)
testb %cl, %cl
je 0xb698
addl $-0x2, %ebp
addl $-0x2, %r15d
incl %r12d
incl %r13d
movl %ebp, %edi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
callq 0x32d0
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xb6d5
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3500
nop
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]todo/src/win.cpp
// Function: Win::draw()
void Win::draw()
{
    box(border, 0, 0);
    inverse(true);
    mvwprintw(border, 0, 0, string("[" + name + "]").c_str());
    inverseOff(true);
    wrefresh(border);
    wrefresh(win);    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3550
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x3190
movq 0x8(%rbx), %r14
leaq 0x20(%rbx), %rdx
leaq 0xd10(%rip), %rsi       # 0xc47c
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x6aa0
leaq 0x88a(%rip), %rsi       # 0xc00a
movq %r15, %rdi
callq 0x3560
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb7ae
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0xb7b5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x30c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb7f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb810
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
movq 0x8(%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x3380
movq 0x8(%rbx), %rdi
callq 0x3300
movq (%rbx), %rdi
callq 0x3300
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb859
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32b0
jmp 0xb859
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb874
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/basic.hpp
// Function: basic::is_digit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_digit(const std::string& str) {
        if (str == "-") return false;
        for (size_t p = str[0] == '-'; p < str.size(); ++p)
            if (!isdigit(str[p])) return false;
        return true;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3820(%rip), %rsi      # 0x6034
callq 0x2090
testl %eax, %eax
je 0x2864
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
xorl %esi, %esi
cmpb $0x2d, (%rdx)
sete %sil
cmpq %rsi, %rcx
setbe %al
jbe 0x2866
movsbl (%rdx,%rsi), %edi
addl $-0x30, %edi
cmpl $0x9, %edi
ja 0x2866
incq %rsi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x285c
movsbl (%rdx,%rax), %edi
addl $-0x30, %edi
leaq 0x1(%rax), %rsi
cmpl $0xa, %edi
jb 0x2844
cmpq %rcx, %rax
setae %al
jmp 0x2866
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/basic.hpp
// Function: basic::format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
expression format(const string& str) {
        expression result;
        string element;
    
        for (auto ptr = str.begin(); ptr != str.end(); ) {
            if (isspace(*ptr)) {
                ptr++;
                continue;
            }
            element = "";
            if (isalpha(*ptr)) {
                while (isalpha(*ptr))
                    element += *ptr++;
            } else if (isdigit(*ptr)) {
                while (isdigit(*ptr))
                    element += *ptr++;
            } else{
                element += *ptr++;
            }
            result.push_back(element);
        }

        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
cmpq %rax, 0x8(%rsi)
je 0x29f5
movq %rsi, %r14
movq (%rsi), %r15
leaq 0x8(%rsp), %r12
movsbl (%r15), %edi
callq 0x2050
testl %eax, %eax
je 0x2960
incq %r15
jmp 0x29e5
movq 0x10(%rsp), %rdx
movq %r12, %rdi
xorl %esi, %esi
leaq 0x37f8(%rip), %rcx      # 0x6169
xorl %r8d, %r8d
callq 0x2240
movsbl (%r15), %r13d
movl %r13d, %edi
callq 0x2250
testl %eax, %eax
je 0x29a7
movsbl (%r15), %ebp
movl %ebp, %edi
callq 0x2250
testl %eax, %eax
je 0x29da
incq %r15
movq %r12, %rdi
movl %ebp, %esi
callq 0x2170
jmp 0x2989
leal -0x30(%r13), %eax
cmpl $0x9, %eax
ja 0x29cc
movsbl (%r15), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x29da
incq %r15
movsbl %al, %esi
movq %r12, %rdi
callq 0x2170
jmp 0x29b0
movq %r12, %rdi
movl %r13d, %esi
callq 0x2170
incq %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a6a
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r15
jne 0x294b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a11
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a29
jmp 0x2a29
jmp 0x2a29
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a48
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2aa8
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::insert(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool insert (const expression& expr) {
            step s;
            int id = to_int(expr[0]);

            if (expr.size() == 1) {
                if (program.count(id)) 
                    program.erase(id);
                return true;
            }
            
            s.expr = expr;
            if (!command_id.count(s.expr[1]))
                return false;
      
            s.type = command_id[s.expr[1]];
            s.expr.erase(s.expr.begin());
            s.expr.erase(s.expr.begin());

            if (!check(s)) return false;
      
            program[id] = s;
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rsi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdi
movb (%rax), %dl
xorl %r8d, %r8d
cmpb $0x2d, %dl
sete %r8b
xorl %r9d, %r9d
cmpq %r8, %rdi
jbe 0x31be
xorl %r9d, %r9d
leal (%r9,%r9,4), %r9d
movsbl (%rax,%r8), %r10d
leal (%r10,%r9,2), %r9d
addl $-0x30, %r9d
incq %r8
cmpq %r8, %rdi
jne 0x31a5
leaq 0x10(%rsp), %rbx
movl %r9d, %eax
negl %eax
cmpb $0x2d, %dl
cmovnel %r9d, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
cmpq $0x20, %rdx
jne 0x3249
movq 0x48(%r14), %rsi
leaq 0x40(%r14), %rcx
movq %rcx, %rdx
testq %rsi, %rsi
je 0x320a
movq %rcx, %rdx
xorl %edi, %edi
cmpl %eax, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x31f3
movq %rcx, %rsi
cmpq %rcx, %rdx
je 0x321c
cmpl 0x20(%rdx), %eax
cmovlq %rcx, %rdx
movq %rdx, %rsi
movb $0x1, %bpl
cmpq %rcx, %rsi
je 0x330c
addq $0x38, %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4e74
movq %r14, %rdi
movq %rax, %rsi
callq 0x4eec
jmp 0x330c
movq %rbx, %rdi
callq 0x4ae2
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x5f57(%rip), %rdi      # 0x91b8
callq 0x5092
leaq 0x5f53(%rip), %rcx      # 0x91c0
cmpq %rcx, %rax
je 0x330a
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x5f32(%rip), %rdi      # 0x91b8
callq 0x4c5c
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5472
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5472
movl 0x8(%rsp), %eax
leaq 0x30(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4870
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x4cd8
movl %eax, %ebp
movq %r15, %rdi
callq 0x2aa8
testb %bpl, %bpl
je 0x330a
addq $0x38, %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4e10
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movb $0x1, %bpl
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4ae2
jmp 0x330c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2aa8
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x2aa8
jmp 0x3335
jmp 0x3332
jmp 0x3332
movq %rax, %r14
movq %rbx, %rdi
callq 0x2aa8
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::compare(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
bool compare(const expr_iter& begin,
                     const expr_iter& end) {
            for (expr_iter ptr = begin + 1; ptr != end; ++ptr) {
                if (*ptr == ">") return eval(begin, ptr) >  eval(ptr + 1, end);
                if (*ptr == "<") return eval(begin, ptr) <  eval(ptr + 1, end);
                if (*ptr == "=") return eval(begin, ptr) == eval(ptr + 1, end);
            }
            return 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, 0x18(%rsp)
leaq 0x291e(%rip), %r13      # 0x6103
leaq 0x2919(%rip), %rbp      # 0x6105
leaq 0x8(%rsp), %r15
movq %rsi, 0x10(%rsp)
movq %rsi, %rcx
movq (%rcx), %rbx
addq $0x20, %rbx
movq %rbx, 0x8(%rsp)
movq (%r14), %r12
cmpq %r12, %rbx
je 0x3902
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2090
testl %eax, %eax
je 0x388a
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x2090
testl %eax, %eax
je 0x38c7
movq 0x8(%rsp), %rdi
leaq 0x28c6(%rip), %rsi      # 0x6107
callq 0x2090
movq %r15, %rcx
testl %eax, %eax
jne 0x37f9
leaq 0x8(%rsp), %r15
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x3952
movl %eax, %ebp
movq (%r15), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
movq %r14, %rdx
callq 0x3952
cmpl %eax, %ebp
sete %cl
jmp 0x3902
leaq 0x8(%rsp), %r15
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x3952
movl %eax, %ebp
movq (%r15), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
movq %r14, %rdx
callq 0x3952
cmpl %eax, %ebp
setg %cl
jmp 0x3902
leaq 0x8(%rsp), %r15
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x3952
movl %eax, %ebp
movq (%r15), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
movq %r14, %rdx
callq 0x3952
cmpl %eax, %ebp
setl %cl
cmpq %r12, %rbx
setne %al
andb %cl, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::eval(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
int eval(const expr_iter& begin,
                 const expr_iter& end) {
            std::vector<expr_iter> match(end - begin), stack;
            for (expr_iter ptr = begin; ptr != end; ptr++) {
                if (*ptr == "(") stack.emplace_back(ptr);
                else if (*ptr == ")") {
                    match[stack.back() - begin] = ptr;
                    stack.pop_back();
                }
            }
            return eval(begin, end, begin, match);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x40(%rsp)
movq (%rdx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x40b8
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq (%rbx), %rdi
movq %rdi, 0x8(%rsp)
cmpq %rdi, (%r14)
je 0x3a1c
leaq 0x275f(%rip), %r12      # 0x6109
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x277f(%rip), %r15      # 0x613a
movq %r12, %rsi
callq 0x2090
testl %eax, %eax
je 0x39fe
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2090
testl %eax, %eax
jne 0x3a09
movq 0x18(%rsp), %rax
movq -0x8(%rax), %rax
subq (%rbx), %rax
movq 0x28(%rsp), %rcx
sarq $0x2, %rax
movq 0x8(%rsp), %rdx
movq %rdx, (%rcx,%rax)
addq $-0x8, 0x18(%rsp)
jmp 0x3a09
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4130
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
cmpq %rdi, (%r14)
jne 0x39bb
leaq 0x28(%rsp), %r8
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4160
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3a4d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3a64
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a77
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3a91
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa8
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void input(const string& name) {
            std::string content;

            do {
                std::cout << " ? ";
                std::getline(std::cin, content);
                if (is_digit(content))
                    break;
                std::cout << "INVALID NUMBER\n";
            } while (true);
            map[name] = to_int(content);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x54ec(%rip), %r15      # 0x8fd0
leaq 0x266b(%rip), %r12      # 0x6156
movq 0x54ee(%rip), %r13      # 0x8fe0
leaq 0x18(%rsp), %rbp
leaq 0x265c(%rip), %rbx      # 0x615a
movl $0x3, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22c0
movq %rbp, %rdi
callq 0x2809
testb %al, %al
jne 0x3b4f
movl $0xf, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21e0
jmp 0x3afe
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movb (%rax), %bl
xorl %edx, %edx
cmpb $0x2d, %bl
sete %dl
xorl %r15d, %r15d
cmpq %rdx, %rcx
jbe 0x3b86
xorl %r15d, %r15d
leal (%r15,%r15,4), %esi
movsbl (%rax,%rdx), %edi
leal (%rdi,%rsi,2), %r15d
addl $-0x30, %r15d
incq %rdx
cmpq %rdx, %rcx
jne 0x3b6e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3bee
movl %r15d, %ecx
negl %ecx
cmpb $0x2d, %bl
cmovnel %r15d, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bba
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bcb
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x3be5
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::eval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int eval(const string& str) {
            if (is_digit(str))
                return to_int(str); 
            ASSERT(map.count(str), VARIABLE_NOT_DEFINED);
            return map[str];
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2809
testb %al, %al
je 0x45c8
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movb (%rax), %cl
xorl %esi, %esi
cmpb $0x2d, %cl
sete %sil
xorl %edi, %edi
cmpq %rsi, %rdx
jbe 0x45bc
xorl %edi, %edi
leal (%rdi,%rdi,4), %edi
movsbl (%rax,%rsi), %r8d
leal (%r8,%rdi,2), %edi
addl $-0x30, %edi
incq %rsi
cmpq %rsi, %rdx
jne 0x45a5
movl %edi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edi, %eax
jmp 0x45e5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4836
testq %rax, %rax
je 0x45ed
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bee
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x20d0
leaq 0x4792(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::operator<<(std::ostream&, basic::basic_interpreter::step const&)
std::ostream& operator<< (std::ostream &sout, const step& s) {
                sout << command[s.type];
                for (auto str : s.expr)
                    sout << ' ' << str;
                sout << std::endl;
                return sout;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rax
shlq $0x5, %rax
leaq 0x47f4(%rip), %rcx      # 0x91f0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
callq 0x21e0
movq 0x8(%r14), %r12
movq 0x10(%r14), %rbp
cmpq %rbp, %r12
je 0x4a86
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
movq %r13, 0x8(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3ea4
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a7d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x4a26
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ad9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::check(basic::basic_interpreter::step)
bool check(step s) {
            switch (s.type) {
            case 1:
                REPORT(s.expr.size() < 3);
                REPORT(!is_var(s.expr[0]));
                REPORT(s.expr[1] != "=");
                REPORT(!check_expr(s.expr.begin() + 2, s.expr.end()));
                break;
            case 2:
                //REPORT(s.expr.size() < 1);
                REPORT(!check_expr(s.expr.begin(), s.expr.end()));
                break;
            case 3:
                REPORT(s.expr.size() != 1);
                REPORT(!check_expr(s.expr.begin(), s.expr.end()));
                break;
            case 4:
                REPORT(s.expr.size() != 0);
                break;
            case 5:
                REPORT(s.expr.size() != 1);
                REPORT(!is_digit(s.expr[0]));
                break;
            case 6:
                REPORT(s.expr.size() < 5);
                REPORT(!is_digit(*(s.expr.end() - 1)));
                REPORT(*(s.expr.end() - 2) != "THEN");
                REPORT(!check_expr(s.expr.begin(), s.expr.end() - 2));
            }

            return true;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl (%rsi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x4db4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1323(%rip), %rcx      # 0x601c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cmpq $0x41, %rax
jb 0x4df0
callq 0x2868
testb %al, %al
je 0x4df0
movq 0x8(%r14), %rdi
addq $0x20, %rdi
leaq 0x13d4(%rip), %rsi      # 0x6107
callq 0x2090
testl %eax, %eax
jne 0x4df0
movq 0x8(%r14), %rax
addq $0x40, %rax
jmp 0x4d94
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cmpq $0x20, %rax
jne 0x4df0
callq 0x2809
jmp 0x4db0
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq %rax, %rdx
subq %rcx, %rdx
cmpq $0x20, %rdx
jne 0x4df0
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
jmp 0x4da0
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
jne 0x4df0
jmp 0x4db4
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x10(%r14), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0x54ea
testb %al, %al
je 0x4df0
movb $0x1, %al
jmp 0x4df2
movq 0x10(%r14), %rdi
movq %rdi, %rax
subq 0x8(%r14), %rax
cmpq $0x81, %rax
jb 0x4df0
addq $-0x20, %rdi
callq 0x2809
testb %al, %al
je 0x4df0
movq 0x10(%r14), %rdi
addq $-0x40, %rdi
leaq 0x1383(%rip), %rsi      # 0x616a
callq 0x2090
testl %eax, %eax
je 0x4dfa
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x10(%r14), %rax
addq $-0x40, %rax
jmp 0x4da0
// File: /workspace/github_cpp_makefile_star2_O1/cla7aye15I4nd[P]basic_interpreter/./lib/program.hpp
// Function: basic::basic_interpreter::check_expr(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
bool check_expr(const expr_iter& begin,
                        const expr_iter& end) {
            int cnt = 0;
            for (auto ptr = begin; ptr != end; ptr++) {
                if (*ptr == "(") {
                    ++cnt;
                    if (ptr + 1 == end) return false;
                    if (*(ptr + 1) == ")") return false;
                }
                if (*ptr == ")") if (--cnt < 0) return false;
                if (is_element(*ptr) && ptr + 1 != end && *(ptr + 1) != ")") {
                    if (ptr + 2 == end || (!is_element(*(ptr + 2)) && *(ptr + 2) != "("))
                        return false;
                }
            }
      
            return cnt == 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r15
cmpq %r15, (%rdx)
sete %bl
je 0x55de
movq %rdx, %r14
xorl %r12d, %r12d
leaq 0xc29(%rip), %r13       # 0x613a
movq %r15, %rdi
leaq 0xbee(%rip), %rsi       # 0x6109
callq 0x2090
testl %eax, %eax
jne 0x5544
incl %r12d
leaq 0x20(%r15), %rdi
cmpq (%r14), %rdi
je 0x55d6
movq %r13, %rsi
callq 0x2090
testl %eax, %eax
je 0x55d6
movq %r15, %rdi
movq %r13, %rsi
callq 0x2090
testl %eax, %eax
jne 0x5560
leal -0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
jle 0x55d3
movq %r15, %rdi
callq 0x2868
testb %al, %al
jne 0x5578
movq %r15, %rdi
callq 0x2809
testb %al, %al
je 0x55c1
leaq 0x20(%r15), %rdi
cmpq (%r14), %rdi
je 0x55c1
movq %r13, %rsi
callq 0x2090
testl %eax, %eax
je 0x55c1
leaq 0x40(%r15), %rbp
cmpq (%r14), %rbp
je 0x55d6
movq %rbp, %rdi
callq 0x2868
testb %al, %al
jne 0x55c1
movq %rbp, %rdi
callq 0x2809
testb %al, %al
jne 0x55c1
movq %rbp, %rdi
leaq 0xb51(%rip), %rsi       # 0x6109
callq 0x2090
testl %eax, %eax
jne 0x55d6
addq $0x20, %r15
cmpq (%r14), %r15
sete %bl
jne 0x5511
jmp 0x55d6
movl %eax, %r12d
testl %r12d, %r12d
sete %al
andb %al, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/pacman.cpp
// Function: Pacman::Pacman()
Pacman::Pacman()
{
        center();
        alive = true;
        head = UP;
        num_moves = 0;
        score = 0;
        dots_eaten = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movabsq $0x1e0000000a, %rax     # imm = 0x1E0000000A
movq %rax, 0x4(%rdi)
movw $0x7601, (%rdi)         # imm = 0x7601
movq $0x0, 0xc(%rdi)
movl $0x0, 0x14(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/pacman.cpp
// Function: Pacman::move(char (*) [61], char)
bool Pacman::move(char board[ROWS][COLS], char command)
{
        bool ate_dot = false;
        rotate_head(command);
        num_moves++;
        if (!boulder_ahead(board, command)){
                board[row][col] = SPACE;
                if (command == CMD_UP){         // move, wrap if needed
                        if (row == 0) {row = ROWS-1;} else {row--;}
                } else if (command == CMD_DWN){
                        if (row == ROWS-1) {row = 0;} else {row++;}
                } else if (command == CMD_RGT){
                        if (col == COLS-1) {col = 0;} else {col++;}
                } else if (command == CMD_LFT){
                        if (col == 0) {col = COLS-1;} else {col--;}
                }
        }
        if (board[row][col] == GHOST)
                die();
        if (board[row][col] == DOT){
                ate_dot = true;
                dots_eaten++;
        }
        return ate_dot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x72, %edx
jg 0x24df
cmpl $0x61, %edx
je 0x24ed
cmpl $0x64, %edx
jne 0x24f6
movb $0x3c, %al
jmp 0x24f3
cmpl $0x77, %edx
je 0x24f1
cmpl $0x73, %edx
jne 0x24f6
movb $0x5e, %al
jmp 0x24f3
movb $0x3e, %al
jmp 0x24f3
movb $0x76, %al
movb %al, 0x1(%rbx)
incl 0xc(%rbx)
movsbl %dl, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x260e
testb %al, %al
je 0x2545
movslq 0x4(%rbx), %rax
movslq 0x8(%rbx), %rcx
imulq $0x3d, %rax, %rax
addq %rax, %r14
leaq (%r14,%rcx), %rax
cmpb $0x6d, (%rcx,%r14)
jne 0x252c
movb $0x0, (%rbx)
movb (%rax), %al
cmpb $0x6f, %al
jne 0x2535
incl 0x14(%rbx)
cmpb $0x6f, %al
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x4(%rbx), %rax
movslq 0x8(%rbx), %rcx
imulq $0x3d, %rax, %rax
addq %r14, %rax
movb $0x20, (%rcx,%rax)
cmpl $0x72, %r15d
jg 0x257b
cmpl $0x61, %r15d
je 0x2592
cmpl $0x64, %r15d
jne 0x250f
movl 0x8(%rbx), %eax
cmpl $0x3c, %eax
jne 0x25b1
movl $0x0, 0x8(%rbx)
jmp 0x250f
cmpl $0x73, %r15d
je 0x259d
cmpl $0x77, %r15d
jne 0x250f
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x25c5
decl %eax
jmp 0x25bd
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x25d1
decl %eax
jmp 0x25b3
movl 0x4(%rbx), %eax
cmpl $0x14, %eax
jne 0x25bb
movl $0x0, 0x4(%rbx)
jmp 0x250f
incl %eax
movl %eax, 0x8(%rbx)
jmp 0x250f
incl %eax
movl %eax, 0x4(%rbx)
jmp 0x250f
movl $0x14, 0x4(%rbx)
jmp 0x250f
movl $0x3c, 0x8(%rbx)
jmp 0x250f
nop
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/pacman.cpp
// Function: Pacman::boulder_ahead(char (*) [61], char)
bool Pacman::boulder_ahead(char board[ROWS][COLS], char command)
{
        if (command == CMD_UP){
                if (row == 0){
                        return (board[ROWS-1][col] == BOULDER);
                } else {
                        return (board[row-1][col] == BOULDER);
                }
        } else if (command == CMD_DWN){
                if (row == ROWS-1){
                        return (board[0][col] == BOULDER);
                } else {
                        return (board[row+1][col] == BOULDER);
                }
        } else if (command == CMD_RGT){
                if (col == COLS-1){
                        return (board[row][0] == BOULDER);
                } else {
                        return (board[row][col+1] == BOULDER);
                }
        } else if (command == CMD_LFT){
                if (col == 0){
                        return (board[row][COLS-1] == BOULDER);
                } else {
                        return (board[row][col-1] == BOULDER);
                }
        }
        return true;  // error case locks Pacman in place
}

// Assembly:
movb $0x1, %al
cmpl $0x72, %edx
jg 0x2637
cmpl $0x61, %edx
je 0x2662
cmpl $0x64, %edx
jne 0x26da
movslq 0x8(%rdi), %rax
movslq 0x4(%rdi), %rcx
cmpq $0x3c, %rax
jne 0x2691
imulq $0x3d, %rcx, %rax
jmp 0x268c
cmpl $0x73, %edx
je 0x267e
cmpl $0x77, %edx
jne 0x26da
movslq 0x4(%rdi), %rax
testq %rax, %rax
je 0x26b4
imulq $0x3d, %rax, %rax
addq %rax, %rsi
movslq 0x8(%rdi), %rax
addq %rax, %rsi
addq $-0x3d, %rsi
jmp 0x26cf
movslq 0x8(%rdi), %rax
movslq 0x4(%rdi), %rcx
testq %rax, %rax
je 0x26c4
imulq $0x3d, %rcx, %rcx
addq %rcx, %rsi
addq %rax, %rsi
decq %rsi
jmp 0x26cf
movslq 0x4(%rdi), %rax
cmpq $0x14, %rax
jne 0x26a0
movslq 0x8(%rdi), %rax
addq %rax, %rsi
jmp 0x26cf
imulq $0x3d, %rcx, %rcx
addq %rcx, %rsi
addq %rax, %rsi
incq %rsi
jmp 0x26cf
imulq $0x3d, %rax, %rax
addq %rax, %rsi
movslq 0x8(%rdi), %rax
addq %rax, %rsi
addq $0x3d, %rsi
jmp 0x26cf
movslq 0x8(%rdi), %rax
addq %rax, %rsi
addq $0x4c4, %rsi            # imm = 0x4C4
jmp 0x26cf
imulq $0x3d, %rcx, %rax
addq %rax, %rsi
addq $0x3c, %rsi
pushq %rbp
movq %rsp, %rbp
cmpb $0x58, (%rsi)
sete %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/ghost.cpp
// Function: Ghost::move(char (*) [61], int, int)
bool Ghost::move(char board[ROWS][COLS], int target_r, int target_c)
{
        int new_row = row;
        int new_col = col; 
        board[row][col] = board_char;   // replace element of board
        if (abs(row-target_r) > abs(col-target_c)){     // never wraps
                if (row > target_r){
                        new_row--;
                } else if (row < target_r){
                        new_row++;
                }
                if (board[new_row][new_col] != GHOST)
                        row = new_row;
        } else {
                if (col > target_c){
                        new_col--;
                } else if (col < target_c){
                        new_col++;
                }
                if (board[new_row][new_col] != GHOST)
                        col = new_col;
        }
        place_on_board(board);
        return (target_r == row && target_c == col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq (%rdi), %r8
movslq 0x4(%rdi), %rax
movb 0x8(%rdi), %r10b
imulq $0x3d, %r8, %r9
addq %rsi, %r9
movb %r10b, (%rax,%r9)
movl (%rdi), %r10d
movl %r10d, %r11d
subl %edx, %r11d
movl %r11d, %ebx
negl %ebx
cmovsl %r11d, %ebx
movl 0x4(%rdi), %r11d
movl %r11d, %r14d
subl %ecx, %r14d
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
cmpl %r15d, %ebx
jbe 0x2845
xorl %r11d, %r11d
cmpl %edx, %r10d
setl %r11b
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmovlel %r11d, %r9d
addl %r8d, %r9d
movslq %r9d, %r8
imulq $0x3d, %r8, %r8
addq %rsi, %r8
cmpb $0x6d, (%rax,%r8)
je 0x286a
movl %r9d, (%rdi)
jmp 0x286a
xorl %r10d, %r10d
cmpl %ecx, %r11d
setl %r10b
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmovlel %r10d, %r8d
addl %eax, %r8d
movslq %r8d, %rax
cmpb $0x6d, (%rax,%r9)
je 0x286a
movl %r8d, 0x4(%rdi)
movslq (%rdi), %rax
movslq 0x4(%rdi), %r8
imulq $0x3d, %rax, %rax
addq %rax, %rsi
leaq (%rsi,%r8), %rax
movb (%r8,%rsi), %sil
cmpb $0x6d, %sil
je 0x288a
movb %sil, 0x8(%rdi)
movb $0x6d, (%rax)
xorl (%rdi), %edx
xorl 0x4(%rdi), %ecx
orl %edx, %ecx
sete %al
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/game.cpp
// Function: Game::print_manual()
void Game::print_manual()
{
        screen_clear();
        cout << "PACMAN GAME\n"
                "            \n"
                " Move left:    " << CMD_LFT << "\n"
                " Move right:   " << CMD_RGT << "\n"
                " Move up:      " << CMD_UP  << "\n"
                " Move down:    " << CMD_DWN << "\n"
                "\n"
                " Collect all the dots. They look like: " << DOT << "\n"
                " Avoid the ghosts.     They look like: " << GHOST << "\n"
                "\n"
                " Good luck!\n"
                "\n"
                " Press any key to continue...\n";

        getachar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x356a
movq 0x4656(%rip), %rbx      # 0x6fd0
leaq 0x1693(%rip), %rsi      # 0x4014
movl $0x28, %edx
movq %rbx, %rdi
callq 0x20f0
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1691(%rip), %rsi      # 0x403d
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xa(%rbp), %rsi
movb $0x64, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1677(%rip), %rsi      # 0x404e
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xb(%rbp), %rsi
movb $0x77, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x165d(%rip), %rsi      # 0x405f
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xc(%rbp), %rsi
movb $0x73, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1643(%rip), %rsi      # 0x4070
movl $0x29, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xd(%rbp), %rsi
movb $0x6f, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1642(%rip), %rsi      # 0x409a
movl $0x28, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xe(%rbp), %rsi
movb $0x6d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
leaq 0x1643(%rip), %rsi      # 0x40c3
movl $0x2d, %edx
movq %rax, %rdi
callq 0x20f0
callq 0x322c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/game.cpp
// Function: Game::run()
void Game::run()
{
        while (!game_won && p.is_alive()){
                reset_level();
                start_level();
                play_level();
                if (p.is_alive())
                        complete_level();
        }
        if (game_won){
                cout << "You win!\n";
        } else {
                cout << "You lost :(\n";
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x509(%rdi)
jne 0x2b13
leaq 0x50c(%rbx), %r14
movq %r14, %rdi
callq 0x275a
testb %al, %al
je 0x2b13
movq %rbx, %rdi
callq 0x2b4e
movq %rbx, %rdi
callq 0x2bea
movq %rbx, %rdi
callq 0x2c54
movq %r14, %rdi
callq 0x275a
testb %al, %al
je 0x2b0a
movq %r14, %rdi
movl $0xa, %esi
callq 0x2746
movl 0x504(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x504(%rbx)
cmpl $0xa, %eax
setge 0x509(%rbx)
cmpb $0x1, 0x509(%rbx)
jne 0x2ab4
cmpb $0x1, 0x509(%rbx)
jne 0x2b31
movq 0x44ad(%rip), %rdi      # 0x6fd0
leaq 0x15c7(%rip), %rsi      # 0x40f1
movl $0x9, %edx
jmp 0x2b44
movq 0x4498(%rip), %rdi      # 0x6fd0
leaq 0x15bc(%rip), %rsi      # 0x40fb
movl $0xc, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
nop