LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: Node::split_node(unsigned long)
std::tuple<Node*, Node*> Node::split_node(Window new_window)
{
    Node* left_child = new Node();
    Node* right_child = new Node();

    left_child->set_window(this->window);
    right_child->set_window(new_window);

    int split_width = this->width, split_height = this->height;
    int split_x = this->x, split_y = this->y;
    if (this->width >= this->height) {
        split_width /= 2;
        split_x += split_width;
        left_child->set_dimensions(split_width, this->height, this->x, this->y);
        right_child->set_dimensions(this->width - split_width, this->height, split_x, this->y);
    } else if (this->width < this->height) {
        split_height /= 2;
        split_y += split_height;
        left_child->set_dimensions(this->width, split_height, this->x, this->y);
        right_child->set_dimensions(this->width, this->height - split_height, this->x, split_y);
    }

    set_children(left_child, right_child);

    return std::make_tuple(left_child, right_child);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0x3230
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movl $0x28, %edi
callq 0x3230
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%r15)
movq %r12, 0x10(%rax)
movl (%r14), %ecx
movl 0x4(%r14), %edx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edi
cmpl %edx, %ecx
jge 0x7091
movl %edx, %r8d
shrl $0x1f, %r8d
addl %edx, %r8d
sarl %r8d
movl %ecx, (%r15)
movl %r8d, 0x4(%r15)
movl %esi, 0x8(%r15)
movl %edi, 0xc(%r15)
addl %r8d, %edi
subl %r8d, %edx
jmp 0x70b3
movl %ecx, %r8d
shrl $0x1f, %r8d
addl %ecx, %r8d
sarl %r8d
movl %r8d, (%r15)
movl %edx, 0x4(%r15)
movl %esi, 0x8(%r15)
addl %r8d, %esi
movl %edi, 0xc(%r15)
subl %r8d, %ecx
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movl %esi, 0x8(%rax)
movl %edi, 0xc(%rax)
movq %r15, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::init_root(unsigned long, int, int, int, int)
std::tuple<Node*, Node*> BSP::init_root(Window w, int width, int height, int x, int y)
{
    root = new Node();
    root->set_window(w);
    root->set_dimensions(width, height, x, y);
    return std::make_tuple(nullptr, root);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x28, %edi
callq 0x3230
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq %rax, (%r12)
movq %r15, 0x10(%rax)
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movl %ebx, 0x8(%rax)
movl 0x40(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq %rax, (%r13)
movq $0x0, 0x8(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::find_node(unsigned long)
Node* BSP::find_node(Window w)
{
    if (root == nullptr) {
        std::cout << "No root window present\n";
    }
    Node* res = find_node_util(w, root);
    if (res == nullptr) {
        std::cout << "Window not found\n";
    }
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0x718e
movq 0x7e5b(%rip), %rdi      # 0xefd8
leaq 0x3a41(%rip), %rsi      # 0xabc5
movl $0x17, %edx
callq 0x32a0
movq (%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7148
movq %rax, %rbx
testq %rax, %rax
jne 0x71bc
movq 0x7e2d(%rip), %rdi      # 0xefd8
leaq 0x3a7b(%rip), %rsi      # 0xac2d
movl $0x11, %edx
callq 0x32a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::create_node(unsigned long)
std::tuple<Node*, Node*> BSP::create_node(Window w)
{
    Node* current = find_node(w);
    if (current == nullptr) {
        std::cout << "Cannot create new window\n";
        return std::make_tuple(nullptr, nullptr);
    } else {
        return current->split_node(w);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x7166
testq %rax, %rax
je 0x71f2
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7018
jmp 0x7210
movq 0x7ddf(%rip), %rdi      # 0xefd8
leaq 0x39dd(%rip), %rsi      # 0xabdd
movl $0x19, %edx
callq 0x32a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::find_to_delete_node(unsigned long, Node*)
std::tuple<Node*, Node*> BSP::find_to_delete_node(Window w, Node* current)
{
    if (current == nullptr) {
        std::cout << "Node to delete not found.\n";
        return std::make_tuple(nullptr, nullptr);
    }

    if (current->is_leaf() && current == root && current->get_window() == w) {
        return std::make_tuple(current, nullptr);
    }

    if (current->is_leaf() == false && current->get_left_child()->is_leaf()
        && current->get_left_child()->get_window() == w) {
        return std::make_tuple(current->get_left_child(), current);
    } else if (current->is_leaf() == false && current->get_right_child()->is_leaf()
        && current->get_right_child()->get_window() == w) {
        return std::make_tuple(current->get_right_child(), current);
    } else {
        Node* foundWindow;
        Node* foundParentWindow;
        std::tie(foundWindow, foundParentWindow) = find_to_delete_node(w, current->get_right_child());
        if (foundWindow == nullptr && foundParentWindow == nullptr) {
            std::tie(foundWindow, foundParentWindow) = find_to_delete_node(w, current->get_left_child());
        }
        return std::make_tuple(foundWindow, foundParentWindow);
    }
    return std::make_tuple(nullptr, nullptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rcx, %rcx
je 0x7286
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movq %rax, %rdx
orq %rcx, %rdx
sete %dl
jne 0x7269
cmpq %r14, (%r12)
jne 0x7269
cmpq %r15, 0x10(%r14)
jne 0x7269
movq $0x0, (%rbx)
movq %r14, 0x8(%rbx)
jmp 0x7303
testb %dl, %dl
jne 0x72bf
movq 0x20(%rax), %rsi
orq 0x18(%rax), %rsi
jne 0x72a6
cmpq %r15, 0x10(%rax)
jne 0x72a6
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x7303
movq 0x7d4b(%rip), %rdi      # 0xefd8
leaq 0x3963(%rip), %rsi      # 0xabf7
movl $0x1a, %edx
callq 0x32a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x7303
testb %dl, %dl
jne 0x72bf
movq 0x20(%rcx), %rax
orq 0x18(%rcx), %rax
jne 0x72bf
cmpq %r15, 0x10(%rcx)
jne 0x72bf
movq %r14, (%rbx)
jmp 0x72ff
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x721c
movq (%r13), %rax
movq 0x8(%r13), %rcx
movq %rax, %rdx
orq %rcx, %rdx
jne 0x72fc
movq 0x18(%r14), %rcx
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x721c
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::delete_node(unsigned long)
std::tuple<Node*, Node*> BSP::delete_node(Window w)
{
    Node* foundWindow;
    Node* foundParentWindow;
    std::tie(foundWindow, foundParentWindow) = find_to_delete_node(w, root);

    if (foundWindow == nullptr && foundParentWindow == nullptr) {
        std::cout << "No node found :((.\n";
        return std::make_tuple(nullptr, nullptr);
    } else if (foundWindow != nullptr && foundParentWindow == nullptr) {
        delete root;
        root = nullptr;
        return std::make_tuple(nullptr, nullptr);
    } else {
        if (foundWindow == foundParentWindow->get_left_child()) {
            delete foundWindow;
            foundParentWindow = foundParentWindow->get_right_child();
        } else if (foundWindow == foundParentWindow->get_right_child()) {
            delete foundWindow;
            foundParentWindow = foundParentWindow->get_left_child();
        }
    }

    return std::make_tuple(nullptr, nullptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq %rsp, %r15
movq %r15, %rdi
callq 0x721c
movq (%r15), %rax
movq 0x8(%r15), %rdi
movq %rdi, %rcx
orq %rax, %rcx
jne 0x735a
movq 0x7c91(%rip), %rdi      # 0xefd8
leaq 0x38c4(%rip), %rsi      # 0xac12
movl $0x13, %edx
callq 0x32a0
jmp 0x73a3
testq %rax, %rax
sete %cl
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7388
movq (%r14), %rdi
testq %rdi, %rdi
je 0x737f
movl $0x28, %esi
callq 0x3250
movq $0x0, (%r14)
jmp 0x73a3
cmpq 0x18(%rax), %rdi
je 0x73b6
testq %rdi, %rdi
je 0x73a3
cmpq 0x20(%rax), %rdi
jne 0x73a3
movl $0x28, %esi
callq 0x3250
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %rdi, %rdi
jne 0x7399
jmp 0x73a3
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::display_tree_util(Node*)
void BSP::display_tree_util(Node* current)
{
    if (current->get_left_child() != nullptr) {
        display_tree_util(current->get_left_child());
    }
    if (current->get_right_child() != nullptr) {
        display_tree_util(current->get_right_child());
    }
    current->print();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x73d9
movq %r14, %rdi
callq 0x73be
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x73ea
movq %r14, %rdi
callq 0x73be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f52
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/master_stack.cpp
// Function: MasterStack::erase(unsigned long)
void MasterStack::erase(Window w)
{
    std::vector<Window>::iterator pos = find(stack.begin(), stack.end(), w);
    if (pos == stack.end()) {
        std::cout << "Error: Window not found\n";
        return;
    }
    stack.erase(pos);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x7723
movq 0x8(%rbx), %rdx
cmpq %rdx, %rax
je 0x7496
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0x748f
subq %rsi, %rdx
movq %rax, %rdi
callq 0x33d0
addq $-0x8, 0x8(%rbx)
jmp 0x74ae
movq 0x7b3b(%rip), %rdi      # 0xefd8
leaq 0x3782(%rip), %rsi      # 0xac26
movl $0x18, %edx
callq 0x32a0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/master_stack.cpp
// Function: MasterStack::swapMaster(unsigned long)
void MasterStack::swapMaster(Window stack_window)
{
    std::vector<Window>::iterator posCurrent = find(stack.begin(), stack.end(), stack[0]);
    std::vector<Window>::iterator posStack = find(stack.begin(), stack.end(), stack_window);
    if (posCurrent == stack.end() || posStack == stack.end()) {
        std::cout << "Error: Window not found\n";
        return;
    }
    std::swap(*posCurrent, *posStack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movq %rdi, %rdx
callq 0x7723
movq %rax, %rbx
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
callq 0x7723
movq 0x8(%r14), %rcx
cmpq %rcx, %rbx
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x751a
movq 0x7ad1(%rip), %rdi      # 0xefd8
leaq 0x3718(%rip), %rsi      # 0xac26
movl $0x18, %edx
callq 0x32a0
jmp 0x7526
movq (%rbx), %rcx
movq (%rax), %rdx
movq %rdx, (%rbx)
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::insert(unsigned long)
void PriorityQueue::insert(Window w)
{
    numWindows += 1;
    priority[w] = numWindows;
    window.push_back({ numWindows, w });

    int index = queueSize() - 1;
    heapify_up(index);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %rsi, (%r14)
movl 0x50(%rdi), %ebp
incl %ebp
movl %ebp, 0x50(%rdi)
addq $0x18, %rdi
movq %r14, %rsi
callq 0x7c02
movl %ebp, (%rax)
movl 0x50(%rbx), %eax
movl %eax, 0x8(%rsp)
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7979
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x7986
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7eea
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
shrq $0x4, %rsi
decl %esi
movq %rbx, %rdi
callq 0x7892
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::swapPriority(unsigned long, unsigned long)
void PriorityQueue::swapPriority(Window a,Window b){
    if(!priority.count(a) || !priority.count(b)){
        std::cout << "Swap window not found" << std::endl;
        return;
    }

    int temp = priority[a];
    priority[a] = priority[b];
    priority[b] = temp;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, (%rsp)
addq $0x18, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x802a
testq %rax, %rax
je 0x7b1d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x802a
testq %rax, %rax
je 0x7b1d
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c02
movl (%rax), %ebp
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c02
movl (%rax), %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c02
movl %r12d, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c02
movl %ebp, (%rax)
jmp 0x7b5f
movq 0x74b4(%rip), %rbx      # 0xefd8
leaq 0x3135(%rip), %rsi      # 0xac60
movl $0x15, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::Create()
std::unique_ptr<WindowManager> WindowManager::Create()
{
    Display* display = XOpenDisplay(nullptr);
    if (display == nullptr) {
        std::cout << "Failed to open X display " << XDisplayName(nullptr) << std::endl;
        return nullptr;
    }
    std::unique_ptr<WindowManager> wmInstance(new WindowManager(display));
    return wmInstance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3310
testq %rax, %rax
je 0x8094
movq %rax, %r15
movl $0x78, %edi
callq 0x3230
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x8148
jmp 0x8123
movq 0x6f3d(%rip), %r14      # 0xefd8
leaq 0x2c76(%rip), %rsi      # 0xad18
movl $0x19, %edx
movq %r14, %rdi
callq 0x32a0
xorl %edi, %edi
callq 0x33a0
testq %rax, %rax
je 0x80da
movq %rax, %r15
movq %rax, %rdi
callq 0x30e0
movq 0x6f0b(%rip), %rdi      # 0xefd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x32a0
jmp 0x80f2
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3400
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
movq $0x0, (%rbx)
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnXError(_XDisplay*, XErrorEvent*)
int WindowManager::OnXError(Display* display, XErrorEvent* e)
{
    const int MAX_ERROR_TEXT_LENGTH = 1024;
    char error_text[MAX_ERROR_TEXT_LENGTH];
    XGetErrorText(display, e->error_code, error_text, sizeof(error_text));

    std::cout << "Received X error:\n"
              << "    Request: " << int(e->request_code)
              << " - " << XRequestCodeToString(e->request_code) << "\n"
              << "    Error code: " << int(e->error_code)
              << " - " << error_text << "\n"
              << "    Resource ID: " << e->resourceid << "\n";
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rsi, %rbx
movzbl 0x20(%rsi), %esi
leaq 0x20(%rsp), %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x3330
movq 0x6a41(%rip), %r14      # 0xefd8
leaq 0x2c8e(%rip), %rsi      # 0xb22c
movl $0x12, %edx
movq %r14, %rdi
callq 0x32a0
leaq 0x2c8d(%rip), %rsi      # 0xb23f
movl $0xd, %edx
movq %r14, %rdi
callq 0x32a0
movzbl 0x21(%rbx), %esi
movq %r14, %rdi
callq 0x3410
movq %rax, %r14
leaq 0x2c78(%rip), %rsi      # 0xb24d
movl $0x3, %edx
movq %rax, %rdi
callq 0x32a0
movzbl 0x21(%rbx), %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0x465b
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x32a0
movq %rax, %r14
leaq 0x2b11(%rip), %rsi      # 0xb11b
movl $0x1, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x2c33(%rip), %rsi      # 0xb251
movl $0x10, %edx
movq %r14, %rdi
callq 0x32a0
movzbl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x3410
movq %rax, %r14
leaq 0x2c0c(%rip), %rsi      # 0xb24d
movl $0x3, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x30e0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x32a0
leaq 0x2aab(%rip), %rsi      # 0xb11b
movl $0x1, %edx
movq %r14, %rdi
callq 0x32a0
leaq 0x2bde(%rip), %rsi      # 0xb262
movl $0x11, %edx
movq %r14, %rdi
callq 0x32a0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3170
leaq 0x2a77(%rip), %rsi      # 0xb11b
movl $0x1, %edx
movq %rax, %rdi
callq 0x32a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x86cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x86f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnUnmapNotify(XUnmapEvent const&)
void WindowManager::OnUnmapNotify(const XUnmapEvent& e)
{
    if (!clients_.count(e.window)) {
        std::cout << "Ignore UnmapNotify for non-client window " << e.window;
        return;
    }

    if (e.event == root_) {
        std::cout << "Ignore UnmapNotify for reparented pre-existing window "
                  << e.window;
        return;
    }

    Unframe(e.window);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x10, %rdi
leaq 0x28(%rsi), %rbx
movq %rbx, %rsi
callq 0x93fc
testq %rax, %rax
je 0x8c6b
movq 0x20(%r15), %rax
cmpq 0x8(%r14), %rax
jne 0x8c96
movq 0x637b(%rip), %r14      # 0xefd8
leaq 0x235a(%rip), %rsi      # 0xafbe
movl $0x36, %edx
jmp 0x8c7e
movq 0x6366(%rip), %r14      # 0xefd8
leaq 0x231b(%rip), %rsi      # 0xaf94
movl $0x29, %edx
movq %r14, %rdi
callq 0x32a0
movq (%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3170
movq (%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9210
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnConfigureRequest(XConfigureRequestEvent const&)
void WindowManager::OnConfigureRequest(const XConfigureRequestEvent& e)
{
    XWindowChanges changes;
    // Copy fields from e to changes.
    changes.x = e.x;
    changes.y = e.y;
    changes.width = e.width;
    changes.height = e.height;
    changes.border_width = e.border_width;
    changes.sibling = e.above;
    changes.stack_mode = e.detail;
    if (clients_.count(e.window)) {
        const Window frame = clients_[e.window];
        XConfigureWindow(display_, frame, e.value_mask, &changes);
        std::cout << "Resize [" << frame << "] to " << Size<int>(e.width, e.height);
    }
    XConfigureWindow(display_, e.window, e.value_mask, &changes);
    std::cout << "Resize " << e.window << " to " << Size<int>(e.width, e.height);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x30(%rsi), %eax
movl %eax, 0x10(%rsp)
movl 0x34(%rsi), %eax
movl %eax, 0x14(%rsp)
movl 0x38(%rsi), %eax
movl %eax, 0x18(%rsp)
movl 0x3c(%rsi), %eax
movl %eax, 0x1c(%rsp)
movl 0x40(%rsi), %eax
movl %eax, 0x20(%rsp)
movq 0x48(%rsi), %rax
movq %rax, 0x28(%rsp)
movl 0x50(%rsi), %eax
movl %eax, 0x30(%rsp)
leaq 0x10(%rdi), %r15
leaq 0x28(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x93fc
testq %rax, %rax
je 0x8d9e
movq %r15, %rdi
movq %r12, %rsi
callq 0x96f8
movq (%rax), %r15
movq (%r14), %rdi
movl 0x58(%rbx), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rsi
callq 0x3260
movq 0x6284(%rip), %r12      # 0xefd8
leaq 0x229a(%rip), %rsi      # 0xaff5
movl $0x8, %edx
movq %r12, %rdi
callq 0x32a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x3170
movq %rax, %r15
leaq 0x2281(%rip), %rsi      # 0xaffe
movl $0x5, %edx
movq %rax, %rdi
callq 0x32a0
movq 0x38(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x9316
movq (%r14), %rdi
movq 0x28(%rbx), %rsi
movl 0x58(%rbx), %edx
leaq 0x10(%rsp), %rcx
callq 0x3260
movq 0x621f(%rip), %r14      # 0xefd8
leaq 0x2244(%rip), %rsi      # 0xb004
movl $0x7, %edx
movq %r14, %rdi
callq 0x32a0
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x3170
movq %rax, %r14
leaq 0x221c(%rip), %rsi      # 0xafff
movl $0x4, %edx
movq %rax, %rdi
callq 0x32a0
movq 0x38(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x9316
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnButtonPress(XButtonEvent const&)
void WindowManager::OnButtonPress(const XButtonEvent& e)
{
    assert(clients_.count(e.window));
    const Window frame = clients_[e.window];

    drag_start_pos_ = Position<int>(e.x_root, e.y_root);

    Window returned_root;
    int x, y;
    unsigned width, height, border_width, depth;
    assert(XGetGeometry(
        display_,
        frame,
        &returned_root,
        &x, &y,
        &width, &height,
        &border_width,
        &depth));
    drag_start_frame_pos_ = Position<int>(x, y);
    drag_start_frame_size_ = Size<int>(width, height);

    XRaiseWindow(display_, frame);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x20(%rsi), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x93fc
testq %rax, %rax
je 0x8ecf
movq %r14, %rdi
movq %r12, %rsi
callq 0x96f8
movq (%rax), %r14
movq 0x48(%r15), %rax
movq %rax, 0x50(%rbx)
movq (%rbx), %rdi
subq $0x8, %rsp
leaq 0x20(%rsp), %rax
leaq 0x24(%rsp), %r10
leaq 0x10(%rsp), %r11
leaq 0x28(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x14(%rsp), %r9
movq %r14, %rsi
pushq %rax
pushq %r10
pushq %r11
callq 0x3360
addq $0x20, %rsp
testl %eax, %eax
je 0x8eee
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x58(%rbx)
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x60(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3290
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2136(%rip), %rdi      # 0xb00c
leaq 0x1f0a(%rip), %rsi      # 0xade7
leaq 0x2141(%rip), %rcx      # 0xb025
movl $0x13b, %edx            # imm = 0x13B
callq 0x3160
leaq 0x2168(%rip), %rdi      # 0xb05d
leaq 0x1eeb(%rip), %rsi      # 0xade7
leaq 0x2122(%rip), %rcx      # 0xb025
movl $0x14a, %edx            # imm = 0x14A
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnMotionNotify(XMotionEvent const&)
void WindowManager::OnMotionNotify(const XMotionEvent& e)
{
    assert(clients_.count(e.window));
    const Window frame = clients_[e.window];
    const Position<int> drag_pos(e.x_root, e.y_root);
    const Vector2D<int> delta = drag_pos - drag_start_pos_;

    if (e.state & Button1Mask) {
        // alt + left button: Move window.
        const Position<int> dest_frame_pos = drag_start_frame_pos_ + delta;
        XMoveWindow(
            display_,
            frame,
            dest_frame_pos.x, dest_frame_pos.y);
    } else if (e.state & Button3Mask) {
        // alt + right button: Resize window.
        // Window dimensions cannot be negative.
        const Vector2D<int> size_delta(
            std::max(delta.x, -drag_start_frame_size_.width),
            std::max(delta.y, -drag_start_frame_size_.height));
        const Size<int> dest_frame_size = drag_start_frame_size_ + size_delta;
        // 1. Resize frame.
        XResizeWindow(
            display_,
            frame,
            dest_frame_size.width, dest_frame_size.height);
        // 2. Resize client window.
        XResizeWindow(
            display_,
            e.window,
            dest_frame_size.width, dest_frame_size.height);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
leaq 0x20(%rsi), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x93fc
testq %rax, %rax
je 0x8fcb
movq %r12, %rdi
movq %r14, %rsi
callq 0x96f8
movq (%rax), %rsi
movl 0x48(%r15), %edx
movl 0x4c(%r15), %ecx
subl 0x50(%rbx), %edx
movl 0x50(%r15), %eax
subl 0x54(%rbx), %ecx
btl $0x8, %eax
jb 0x8f6f
btl $0xa, %eax
jb 0x8f85
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addl 0x58(%rbx), %edx
addl 0x5c(%rbx), %ecx
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
movl 0x60(%rbx), %eax
movl %eax, %ebp
negl %ebp
cmpl %ebp, %edx
cmovgl %edx, %ebp
movl 0x64(%rbx), %edx
movl %edx, %r15d
negl %r15d
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
addl %eax, %ebp
addl %edx, %r15d
movq (%rbx), %rdi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x3350
movq (%rbx), %rdi
movq (%r14), %rsi
movl %ebp, %edx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3350
leaq 0x203a(%rip), %rdi      # 0xb00c
leaq 0x1e0e(%rip), %rsi      # 0xade7
leaq 0x20dc(%rip), %rcx      # 0xb0bc
movl $0x155, %edx            # imm = 0x155
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::Unframe(unsigned long)
void WindowManager::Unframe(Window w)
{
    assert(clients_.count(w));

    const Window frame = clients_[w];
    XUnmapWindow(display_, frame);
    XReparentWindow(
        display_,
        w,
        root_,
        0, 0);
    XRemoveFromSaveSet(display_, w);
    XDestroyWindow(display_, frame);

    clients_.erase(w);

    std::cout << "Unframed window " << w << " [" << frame << "]";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x93fc
testq %rax, %rax
je 0x92f7
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x96f8
movq (%rax), %rbx
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x3370
movq (%r14), %rsi
movq (%r12), %rdi
movq 0x8(%r12), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3030
movq (%r12), %rdi
movq (%r14), %rsi
callq 0x3450
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x33b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x979e
movq 0x5d42(%rip), %r15      # 0xefd8
leaq 0x1ce4(%rip), %rsi      # 0xaf81
movl $0x10, %edx
movq %r15, %rdi
callq 0x32a0
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3170
movq %rax, %r14
leaq 0x1d3c(%rip), %rsi      # 0xaffb
movl $0x2, %edx
movq %rax, %rdi
callq 0x32a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3170
leaq 0x1cb4(%rip), %rsi      # 0xaf92
movl $0x1, %edx
movq %rax, %rdi
callq 0x32a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b47(%rip), %rdi      # 0xae45
leaq 0x1ae2(%rip), %rsi      # 0xade7
leaq 0x1c51(%rip), %rcx      # 0xaf5d
movl $0xf4, %edx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/main.cpp
// Function: main
int main(int argc, char** argv)
{

    /* std::unique_ptr<WindowManager> window_manager = std::make_unique<WindowManager>(WindowManager::Create()); */
    std::unique_ptr<WindowManager> window_manager(WindowManager::Create());
    if (!window_manager) {
        std::cout << "Failed to initialize window manager.";
        return EXIT_FAILURE;
    }
    std::cout<<"Window manager running"<<std::endl;
    window_manager->Run();

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8060
cmpq $0x0, (%rbx)
je 0x9994
movq 0x5691(%rip), %rbx      # 0xefd8
leaq 0x194b(%rip), %rsi      # 0xb299
movl $0x16, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3220
movsbl %al, %esi
movq 0x565f(%rip), %rdi      # 0xefd8
callq 0x3040
movq %rax, %rdi
callq 0x3180
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
callq 0x8224
jmp 0x99b1
movl $0x1, %ebx
movq 0x5638(%rip), %rdi      # 0xefd8
leaq 0x18cd(%rip), %rsi      # 0xb274
movl $0x24, %edx
callq 0x32a0
leaq 0x8(%rsp), %rdi
callq 0x99d8
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x99d8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getValue[abi:cxx11](int, int) const
std::string CTable::getValue(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  returnValue = it->second->getValueAsString();
    }

    return returnValue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x38(%rsi), %rdi
shlq $0x20, %rcx
movl %edx, %eax
orq %rcx, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x691e
addq $0x40, %r14
cmpq %r14, %rax
je 0x5d06
movq 0x28(%rax), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x28(%rax)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5d06
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5d15
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5d2b
movq (%r15), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getCell(int, int) const
CCell * CTable::getCell(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  return it->second;
    } else {
	  throw std::logic_error("ERR: empty cell");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0x38, %rdi
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
callq 0x691e
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x5da0
movq 0x28(%rax), %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5d93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x4150
movq %rax, %r14
leaq 0x86cc(%rip), %rsi      # 0xe480
movq %rax, %rdi
callq 0x4430
movq 0xd215(%rip), %rsi      # 0x12fd8
movq 0xd1f6(%rip), %rdx      # 0x12fc0
movq %r14, %rdi
callq 0x4560
jmp 0x5de1
movq %rax, %rbx
movq %r14, %rdi
callq 0x4210
jmp 0x5de4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5dfb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getExpression[abi:cxx11](int, int) const
std::string CTable::getExpression(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  returnValue = it->second->getExpression();
    }

    return returnValue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x38(%rsi), %rdi
shlq $0x20, %rcx
movl %edx, %eax
orq %rcx, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x691e
addq $0x40, %r14
cmpq %r14, %rax
je 0x5e7c
movq 0x28(%rax), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x30(%rax)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5e7c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5e8b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5ea1
movq (%r15), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::set<std::pair<int, int>> CEquation::update(std::string exp) {
    m_error = false;

    m_affectedBy.clear();
    m_expression = exp;

    compute();

    return m_affectedBy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb $0x0, 0x58(%rsi)
leaq 0x88(%rsi), %r12
movq %r12, %rdi
callq 0x5fe0
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4190
movq %r14, %rdi
callq 0x6c1a
movq %r15, %rdi
movq %r12, %rsi
callq 0x600e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::compute()
void CEquation::compute() {
    std::string s = replaceOtherCells(m_expression);
    if (!m_error) {
	  CExpressionParser parser(s);

	  if (!parser.MatchingParetheses()) {
		m_error = true;
		m_errorMsg = "ERR: mismatched parentheses or empty input";
	  } else {
		std::vector<std::string> RPN;

		if (parser.InfixToRPN(RPN)) {
		    std::string str_result;
		    if (parser.Evaluate(RPN, str_result)) {
			  m_value = string_to_double(str_result);
		    }
		} else {
		    m_error = true;
		    m_errorMsg = "ERR: mismatched parentheses";
		}
	  }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x5370
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6fee
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c74
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
cmpb $0x0, 0x58(%rbx)
jne 0x6d7c
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
callq 0xaa1e
movq %rsp, %rdi
callq 0xaa62
testb %al, %al
je 0x6d0f
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rsp, %rdi
callq 0xc484
testb %al, %al
je 0x6d34
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xb79c
testb %al, %al
je 0x6cf6
leaq 0x20(%rsp), %rsi
callq 0x6f54
movsd %xmm0, 0x80(%rbx)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6d57
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x6d57
movb $0x1, 0x58(%rbx)
movq 0x68(%rbx), %rdx
addq $0x60, %rbx
leaq 0x78b1(%rip), %rcx      # 0xe5d3
movl $0x2a, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a0
jmp 0x6d61
movb $0x1, 0x58(%rbx)
movq 0x68(%rbx), %rdx
addq $0x60, %rbx
leaq 0x78b7(%rip), %rcx      # 0xe5fe
movl $0x1b, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a0
leaq 0x40(%rsp), %rdi
callq 0x83ae
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d7c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d9d
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6dc9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x6dc9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x83ae
jmp 0x6ddd
movq %rax, %rbx
jmp 0x6df8
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6df8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x90(%rsp), %r15
movq -0x10(%r15), %rdi
jmp 0x6e0e
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e1e
movq (%r15), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::getValue() const
double CEquation::getValue() const {
    if (m_error) {
	  throw std::logic_error(m_errorMsg);
    } else {
	  return m_value;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
je 0x6e4e
movsd 0x80(%r14), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4150
movq %rax, %rbx
addq $0x60, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4450
movq 0xc167(%rip), %rsi      # 0x12fd8
movq 0xc148(%rip), %rdx      # 0x12fc0
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::getValueAsString[abi:cxx11]() const
std::string CEquation::getValueAsString() const {
    if (m_error) {
	  return m_errorMsg;
    } else {
	  std::ostringstream out;
	  out << std::setprecision(3) << m_value;
	  return out.str();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x58(%rsi)
jne 0x6ec8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5370
jmp 0x6f1e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x43f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsp,%rax)
movsd 0x80(%r14), %xmm0
movq %r15, %rdi
callq 0x44e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44d0
movq 0xc0a6(%rip), %rsi      # 0x12fb0
leaq 0x8(%rsp), %rdi
callq 0x4180
leaq 0x78(%rsp), %rdi
callq 0x40d0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xc078(%rip), %rsi      # 0x12fb0
leaq 0x8(%rsp), %rdi
callq 0x4180
leaq 0x78(%rsp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::string_to_double(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CEquation::string_to_double(const std::string& s) {
    std::istringstream i(s);
    double x;
    if (!(i >> x))
	  return 0;
    return x;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x4530
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x41c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x6f8e
xorps %xmm0, %xmm0
jmp 0x6f94
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0xc008(%rip), %rsi      # 0x12fa8
leaq 0x10(%rsp), %rdi
callq 0x4420
leaq 0x88(%rsp), %rdi
callq 0x40d0
movsd (%rsp), %xmm0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xbfd9(%rip), %rsi      # 0x12fa8
leaq 0x10(%rsp), %rdi
callq 0x4420
leaq 0x88(%rsp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CRuntime.cpp
// Function: CRuntime::CRuntime()
CRuntime::CRuntime() : m_currentView(-1) {
    m_controller = NULL;

    initscr();
    keypad(stdscr, TRUE);
    if (has_colors()) {
	  start_color();
    }
    init_pair(1, COLOR_BLACK, COLOR_WHITE);

    m_controllers.insert(std::make_pair((int) SPLASHSCREEN_VIEW, new CSplashscreenController()));
    m_controllers.insert(std::make_pair((int) WELCOME_VIEW, new CWelcomeController()));
    m_controllers.insert(std::make_pair((int) TABLE_VIEW, new CTableController()));
    m_controllers.insert(std::make_pair((int) HELP_VIEW, new CHelpController()));

    try {
	  changeView(WELCOME_VIEW);
    } catch (const std::invalid_argument& e) {
	  throw e;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xa625(%rip), %rax      # 0x12c58
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x10(%rdi), %rax
movl $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %rcx, 0x40(%rdi)
callq 0x4460
movq 0xa94a(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x4100
callq 0x44b0
testb %al, %al
je 0x8689
callq 0x4080
movl $0x1, %edi
xorl %esi, %esi
movl $0x7, %edx
callq 0x4050
movl $0x8, %edi
callq 0x42c0
leaq 0xa615(%rip), %rcx      # 0x12cc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8ca2
movl $0x8, %edi
callq 0x42c0
leaq 0xa630(%rip), %rcx      # 0x12d08
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x1, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8dea
movl $0x88, %edi
callq 0x42c0
movq %rax, %r15
movq %rax, %rdi
callq 0x9118
movq %rsp, %rsi
movl $0x2, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8e86
movl $0x8, %edi
callq 0x42c0
leaq 0xa379(%rip), %rcx      # 0x12aa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x3, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8f22
movq %r14, %rdi
movl $0x1, %esi
callq 0x87f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x87e0
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movl $0x10, %edi
callq 0x4150
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4520
movq 0xa80c(%rip), %rax      # 0x12fa0
addq $0x10, %rax
movq %rax, (%r15)
movq 0xa83e(%rip), %rsi      # 0x12fe0
movq 0xa81f(%rip), %rdx      # 0x12fc8
movq %r15, %rdi
callq 0x4560
movq %rax, %r14
callq 0x4510
jmp 0x87e0
movq %rax, %rdi
callq 0x5314
movq %rax, %r14
movl $0x88, %esi
movq %r15, %rdi
callq 0x42d0
jmp 0x87e0
jmp 0x87dd
jmp 0x87dd
jmp 0x87dd
jmp 0x87dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c52
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CRuntime.cpp
// Function: CRuntime::changeView(int)
void CRuntime::changeView(int view) {
    auto it = m_controllers.find(view);
    if (it == m_controllers.end()) {
	  throw std::invalid_argument("unknown view");
    }


    m_currentView = view;
    m_controller = m_controllers[view];

    m_controller->redraw();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq 0x18(%rdi), %rdx
leaq 0x10(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x8825
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x880e
movq %rax, %rdx
cmpq %rax, %rcx
je 0x8837
cmpl %esi, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x8862
leaq 0x8(%rbx), %rdi
movl %esi, 0x38(%rbx)
leaq 0x4(%rsp), %rsi
callq 0x8bee
movq (%rax), %rdi
movq %rdi, 0x40(%rbx)
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4150
movq %rax, %rbx
leaq 0x5db2(%rip), %rsi      # 0xe628
movq %rax, %rdi
callq 0x4600
movq 0xa75b(%rip), %rsi      # 0x12fe0
movq 0xa73c(%rip), %rdx      # 0x12fc8
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::CTableController()
CTableController::CTableController() {
    m_colPosition = 1;
    m_rowPosition = 1;
    m_colStartingPosition = 1;
    m_rowStartingPosition = 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9b62(%rip), %rax      # 0x12c88
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x5704
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x7c(%rbx)
movl $0x1, %eax
movl %eax, 0x78(%rbx)
movl %eax, 0x84(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a00
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::handleKey(int)
void CTableController::handleKey(int key) {
    switch (key) {
	  case 'e':
	  case 'E':
		editExpression();
		break;

	  case KEY_DOWN:
		changeLocation(m_rowPosition + 1, m_colPosition);
		break;

	  case KEY_UP:
		changeLocation(m_rowPosition - 1, m_colPosition);
		break;

	  case KEY_RIGHT:
		changeLocation(m_rowPosition, m_colPosition + 1);
		break;

	  case KEY_LEFT:
		changeLocation(m_rowPosition, m_colPosition - 1);
		break;

	  default:
		break;
    }
}

// Assembly:
leal -0x102(%rsi), %eax
cmpl $0x3, %eax
ja 0x91e0
leaq 0x5476(%rip), %rcx      # 0xe640
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %esi
jmp 0x93e0
cmpl $0x65, %esi
je 0x921c
cmpl $0x45, %esi
jne 0x91f3
jmp 0x921c
retq
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %edx
jmp 0x93e0
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %edx
jmp 0x93e0
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %esi
jmp 0x93e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::editExpression()
void CTableController::editExpression() {
    echo();
    curs_set(1);

    move(4, HEADER_VALUES_COLUMN + 2);
    clrtoeol();

    char str[66];

    move(4, HEADER_VALUES_COLUMN + 2);
    // push already existing expression into the buffer
    std::string expression = m_database.getExpression(m_rowPosition, m_colPosition);
    for (int i = ((int) expression.length() - 1); i >= 0; i--) {
	  ungetch(expression.at(i));
    }
    getnstr(str, 65);

    expression = str;
    m_database.updateElement(m_rowPosition, m_colPosition, expression);

    noecho();
    curs_set(0);

    renderValue();
    renderTable();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x40c0
movl $0x1, %edi
callq 0x4270
movl $0x4, %edi
movl $0xd, %esi
callq 0x41e0
movq 0x9d63(%rip), %r12      # 0x12fb8
movq (%r12), %rdi
callq 0x4300
movl $0x4, %edi
movl $0xd, %esi
callq 0x41e0
leaq 0x8(%rbx), %r14
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e04
movl 0x8(%r15), %r15d
decq %r15
leal 0x1(%r15), %eax
testl %eax, %eax
jle 0x92b5
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
jbe 0x9388
movq (%rsp), %rax
movsbl (%rax,%r15), %edi
decq %r15
callq 0x43c0
jmp 0x928c
movq (%r12), %rdi
leaq 0x40(%rsp), %rsi
movl $0x41, %edx
callq 0x4470
movq %rsp, %r15
movq 0x8(%r15), %r12
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x4130
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x44a0
movl 0x78(%rbx), %ebp
movl 0x7c(%rbx), %r15d
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5370
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x57ee
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x933f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
callq 0x4340
xorl %edi, %edi
callq 0x4270
movq %rbx, %rdi
callq 0x9e8e
movq %rbx, %rdi
callq 0x950e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9376
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5345(%rip), %rdi      # 0xe6d4
movq %r15, %rsi
xorl %eax, %eax
callq 0x4480
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x93bc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x93bc
jmp 0x93b9
jmp 0x93b9
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
nop