LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2330
movq 0x7845(%rip), %rdi      # 0xdfd8
leaq 0x2b26(%rip), %rsi      # 0x92c0
callq 0x2200
leaq 0x2b2d(%rip), %rsi      # 0x92d3
movq %rax, %rdi
callq 0x2200
movzbl 0x21(%rbx), %esi
movq %rax, %rdi
callq 0x2400
leaq 0x2b20(%rip), %rsi      # 0x92e1
movq %rax, %rdi
callq 0x2200
movq %rax, %r14
movzbl 0x21(%rbx), %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0x3310
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x29c2(%rip), %rsi      # 0x91af
movq %rax, %rdi
callq 0x2200
leaq 0x2ae9(%rip), %rsi      # 0x92e5
movq %rax, %rdi
callq 0x2200
movzbl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x2400
leaq 0x2aca(%rip), %rsi      # 0x92e1
movq %rax, %rdi
callq 0x2200
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2200
leaq 0x297c(%rip), %rsi      # 0x91af
movq %rax, %rdi
callq 0x2200
leaq 0x2ab4(%rip), %rsi      # 0x92f6
movq %rax, %rdi
callq 0x2200
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x2952(%rip), %rsi      # 0x91af
movq %rax, %rdi
callq 0x2200
movq %rsp, %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74dc
testq %rax, %rax
je 0x6da6
movq 0x20(%r15), %rax
cmpq 0x8(%r14), %rax
jne 0x6dc9
movq 0x723b(%rip), %rdi      # 0xdfd8
leaq 0x22ae(%rip), %rsi      # 0x9052
jmp 0x6db4
movq 0x722b(%rip), %rdi      # 0xdfd8
leaq 0x2274(%rip), %rsi      # 0x9028
callq 0x2200
movq (%rbx), %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2150
movq (%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x72dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movups 0x30(%rsi), %xmm0
movaps %xmm0, 0x10(%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 0x74dc
testq %rax, %rax
je 0x6eaf
movq %r15, %rdi
movq %r12, %rsi
callq 0x787e
movq (%rax), %r15
movq (%r14), %rdi
movl 0x58(%rbx), %edx
leaq 0x10(%rsp), %rcx
movq %r15, %rsi
callq 0x2240
movq 0x7163(%rip), %rdi      # 0xdfd8
leaq 0x220d(%rip), %rsi      # 0x9089
callq 0x2200
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
leaq 0x21ff(%rip), %rsi      # 0x9092
movq %rax, %rdi
callq 0x2200
movq 0x38(%rbx), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x73e4
movq (%r14), %rdi
movq 0x28(%rbx), %rsi
movl 0x58(%rbx), %edx
leaq 0x10(%rsp), %rcx
callq 0x2240
movq 0x710e(%rip), %rdi      # 0xdfd8
leaq 0x21c7(%rip), %rsi      # 0x9098
callq 0x2200
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x21aa(%rip), %rsi      # 0x9093
movq %rax, %rdi
callq 0x2200
movq 0x38(%rbx), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x73e4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74dc
testq %rax, %rax
je 0x6fd1
movq %r14, %rdi
movq %r12, %rsi
callq 0x787e
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 0x2360
addq $0x20, %rsp
testl %eax, %eax
je 0x6ff0
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 0x2270
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20c8(%rip), %rdi      # 0x90a0
leaq 0x1e9c(%rip), %rsi      # 0x8e7b
leaq 0x20d3(%rip), %rcx      # 0x90b9
movl $0x13b, %edx            # imm = 0x13B
callq 0x2140
leaq 0x20fa(%rip), %rdi      # 0x90f1
leaq 0x1e7d(%rip), %rsi      # 0x8e7b
leaq 0x20b4(%rip), %rcx      # 0x90b9
movl $0x14a, %edx            # imm = 0x14A
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74dc
testq %rax, %rax
je 0x70cd
movq %r12, %rdi
movq %r14, %rsi
callq 0x787e
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 0x7071
btl $0xa, %eax
jb 0x7087
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 0x21c0
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 0x2350
movq (%rbx), %rdi
movq (%r14), %rsi
movl %ebp, %edx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2350
leaq 0x1fcc(%rip), %rdi      # 0x90a0
leaq 0x1da0(%rip), %rsi      # 0x8e7b
leaq 0x206e(%rip), %rcx      # 0x9150
movl $0x155, %edx            # imm = 0x155
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x74dc
testq %rax, %rax
je 0x73ae
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x787e
movq (%rax), %rbx
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x2370
movq (%r15), %rsi
movq (%r12), %rdi
movq 0x8(%r12), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2030
movq (%r12), %rdi
movq (%r15), %rsi
callq 0x2440
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x23b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x7950
movq 0x6c76(%rip), %rdi      # 0xdfd8
leaq 0x1cac(%rip), %rsi      # 0x9015
callq 0x2200
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x1d0f(%rip), %rsi      # 0x908f
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2150
leaq 0x1c8c(%rip), %rsi      # 0x9026
movq %rax, %rdi
callq 0x2200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b24(%rip), %rdi      # 0x8ed9
leaq 0x1abf(%rip), %rsi      # 0x8e7b
leaq 0x1c2e(%rip), %rcx      # 0x8ff1
movl $0xf4, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x638c
cmpq $0x0, (%rbx)
je 0x7b3d
movq 0x64bd(%rip), %rdi      # 0xdfd8
leaq 0x180b(%rip), %rsi      # 0x932d
callq 0x2200
movq %rax, %rdi
callq 0x20e0
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
callq 0x64e8
jmp 0x7b53
movq 0x6494(%rip), %rdi      # 0xdfd8
leaq 0x17bd(%rip), %rsi      # 0x9308
callq 0x2200
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x7b7a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7b7a
movq %rbx, %rdi
callq 0x2420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x38(%rsi), %rdi
shlq $0x20, %rcx
movl %edx, %eax
orq %rcx, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x6876
addq $0x40, %r14
cmpq %r14, %rax
je 0x5b93
movq 0x28(%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x28(%rax)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43b0
movq %r14, %rdi
callq 0x4150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5ba0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4150
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
addq $0x38, %rdi
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x6876
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x5c09
movq 0x28(%rax), %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x4180
movq %rax, %r14
leaq 0x7858(%rip), %rsi      # 0xd473
movq %rax, %rdi
callq 0x4460
movq 0xd3ae(%rip), %rsi      # 0x12fd8
movq 0xd38f(%rip), %rdx      # 0x12fc0
movq %r14, %rdi
callq 0x4560
jmp 0x5c48
movq %rax, %rbx
movq %r14, %rdi
callq 0x4240
jmp 0x5c4b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x38(%rsi), %rdi
shlq $0x20, %rcx
movl %edx, %eax
orq %rcx, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x6876
addq $0x40, %r14
cmpq %r14, %rax
je 0x5cc5
movq 0x28(%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x30(%rax)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43b0
movq %r14, %rdi
callq 0x4150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5cd2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4150
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e56
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x41b0
movq %r14, %rdi
callq 0x6b68
movq %r15, %rdi
movq %r12, %rsi
callq 0x5eb8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x4440
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6e32
leaq 0x78(%rsp), %rdi
callq 0x4150
cmpb $0x0, 0x58(%r14)
jne 0x6c6d
movq %rsp, %rdi
leaq 0x58(%rsp), %rbx
movq %rbx, %rsi
callq 0x9d20
movq %rsp, %rdi
callq 0x9d58
testb %al, %al
je 0x6c29
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rsp, %rdi
callq 0xaeb4
testb %al, %al
je 0x6c43
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xa640
testb %al, %al
je 0x6c1d
leaq 0x38(%rsp), %rsi
callq 0x6dc2
movsd %xmm0, 0x80(%r14)
leaq 0x38(%rsp), %rdi
callq 0x4150
jmp 0x6c5b
movb $0x1, 0x58(%r14)
addq $0x60, %r14
leaq 0x698d(%rip), %rsi      # 0xd5c6
movq %r14, %rdi
callq 0x4610
jmp 0x6c65
movb $0x1, 0x58(%r14)
addq $0x60, %r14
leaq 0x699e(%rip), %rsi      # 0xd5f1
movq %r14, %rdi
callq 0x4610
leaq 0x20(%rsp), %rdi
callq 0x7b9a
movq %rsp, %rdi
callq 0x4150
leaq 0x58(%rsp), %rdi
callq 0x4150
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x4150
jmp 0x6c94
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x7b9a
jmp 0x6ca5
jmp 0x6caf
movq %rax, %r14
movq %rsp, %rdi
callq 0x4150
jmp 0x6cb2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4150
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6cea
movsd 0x80(%r14), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x4180
movq %rax, %rbx
addq $0x60, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
movq 0xc2cd(%rip), %rsi      # 0x12fd8
movq 0xc2ae(%rip), %rdx      # 0x12fc0
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6d57
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4440
jmp 0x6d9c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4430
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsp,%rax)
movsd 0x80(%r14), %xmm0
movq %r15, %rdi
callq 0x44f0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
leaq 0x8(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4540
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x41f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x6dfa
xorps %xmm0, %xmm0
jmp 0x6e00
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4160
movsd (%rsp), %xmm0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/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 0xae15(%rip), %rax      # 0x12c70
movq %rax, (%rdi)
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
orl $-0x1, 0x38(%rdi)
leaq 0x8(%rdi), %rbx
andq $0x0, 0x40(%rdi)
callq 0x4490
movq 0xb127(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x4110
callq 0x44c0
testb %al, %al
je 0x7eaa
callq 0x4090
pushq $0x1
popq %rdi
pushq $0x7
popq %rdx
xorl %esi, %esi
callq 0x4050
pushq $0x8
popq %rdi
callq 0x4310
leaq 0xae12(%rip), %rcx      # 0x12cd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x844a
pushq $0x8
popq %rdi
callq 0x4310
leaq 0xae32(%rip), %rcx      # 0x12d20
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x1, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x85ce
movl $0x88, %edi
callq 0x4310
movq %rax, %r15
movq %rax, %rdi
callq 0x8954
movq %rsp, %rsi
movl $0x2, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8668
pushq $0x8
popq %rdi
callq 0x4310
leaq 0xab7d(%rip), %rcx      # 0x12ac0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x3, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8702
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7ff2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7fe2
movq %r14, %rdi
callq 0x4120
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x4180
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x838a
movq 0xb03c(%rip), %rsi      # 0x12fe0
movq 0xb01d(%rip), %rdx      # 0x12fc8
movq %r15, %rdi
callq 0x4560
movq %rax, %r14
callq 0x4520
jmp 0x7fe2
movq %rax, %rdi
callq 0x535e
movq %rax, %r14
movl $0x88, %esi
movq %r15, %rdi
callq 0x4320
jmp 0x7fe2
jmp 0x7fdf
jmp 0x7fdf
jmp 0x7fdf
jmp 0x7fdf
movq %rax, %r14
movq %rbx, %rdi
callq 0x83f2
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x879c
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x803f
leaq 0x4(%rsp), %rsi
movl (%rsi), %eax
movl %eax, 0x38(%rbx)
movq %r14, %rdi
callq 0x83a4
movq (%rax), %rdi
movq %rdi, 0x40(%rbx)
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x4180
movq %rax, %rbx
leaq 0x55ca(%rip), %rsi      # 0xd61b
movq %rax, %rdi
callq 0x45f0
movq 0xaf80(%rip), %rsi      # 0x12fe0
movq 0xaf61(%rip), %rdx      # 0x12fc8
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/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 0x89f4
leaq 0x4c72(%rip), %rcx      # 0xd650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %esi
jmp 0x8b5e
cmpl $0x65, %esi
je 0x8a30
cmpl $0x45, %esi
jne 0x8a07
jmp 0x8a30
retq
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %edx
jmp 0x8b5e
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %edx
jmp 0x8b5e
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %esi
jmp 0x8b5e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x40d0
pushq $0x1
popq %rdi
callq 0x42a0
pushq $0x4
popq %rbp
pushq $0xd
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x4210
movq 0xa54f(%rip), %r13      # 0x12fb8
movq (%r13), %rdi
callq 0x4350
movl %ebp, %edi
movl %r14d, %esi
callq 0x4210
leaq 0x8(%rbx), %r14
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c5e
movl 0x8(%r15), %r12d
testl %r12d, %r12d
jle 0x8ab5
decq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4620
movsbl (%rax), %edi
callq 0x4400
jmp 0x8a98
movq (%r13), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x41
popq %rdx
callq 0x44a0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x4610
movl 0x78(%rbx), %ebp
movl 0x7c(%rbx), %r15d
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x4440
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x576c
leaq 0x20(%rsp), %rdi
callq 0x4150
callq 0x4370
xorl %edi, %edi
callq 0x42a0
movq %rbx, %rdi
callq 0x93de
movq %rbx, %rdi
callq 0x8c7e
movq %rsp, %rdi
callq 0x4150
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4150
jmp 0x8b4d
jmp 0x8b4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::changeLocation(int, int)
void CTableController::changeLocation(int row, int col) {
    if (row < 1 || col < 1) {
	  return;
    } else {
	  m_rowPosition = row;
	  m_colPosition = col;

	  renderLocation();
	  renderValue();
	  renderExpression();
	  renderTable();
    }
}

// Assembly:
testl %esi, %esi
setle %al
testl %edx, %edx
setle %cl
orb %al, %cl
je 0x8b6d
retq
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x78(%rdi)
movl %edx, 0x7c(%rdi)
callq 0x9362
movq %rbx, %rdi
callq 0x93de
movq %rbx, %rdi
callq 0x945e
movq %rbx, %rdi
popq %rbx
jmp 0x8c7e
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::redraw()
void CTableController::redraw() {
    clear();

    renderHeader();
    renderTable();
    renderMenu();

    refresh();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4570
movq %rbx, %rdi
callq 0x8bba
movq %rbx, %rdi
callq 0x8c7e
callq 0x92e8
popq %rbx
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderHeader() const
void CTableController::renderHeader() const {
    attron(A_BOLD | A_UNDERLINE);
    mvprintw(0, 1, "Position");
    attroff(A_BOLD | A_UNDERLINE);
    renderLocation();

    attron(A_BOLD | A_UNDERLINE);
    mvprintw(3, 1, "Cell Value");
    attroff(A_BOLD | A_UNDERLINE);
    renderValue();

    attron(A_BOLD | A_UNDERLINE);
    mvprintw(4, 1, "Expression");
    attroff(A_BOLD | A_UNDERLINE);
    renderExpression();

    refresh();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa3f0(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4170
leaq 0x4ab4(%rip), %rdx      # 0xd692
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43e0
movq %rbx, %rdi
callq 0x9362
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4170
leaq 0x4a82(%rip), %rdx      # 0xd69b
pushq $0x3
popq %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43e0
movq %rbx, %rdi
callq 0x93de
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4170
leaq 0x4a54(%rip), %rdx      # 0xd6a6
pushq $0x4
popq %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43e0
movq %rbx, %rdi
callq 0x945e
popq %rbx
popq %r14
popq %rbp
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderMenu() const
void CTableController::renderMenu() const {
    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " E - edit the expression ");
    mvprintw(maxY - 1, 27, " F3 - help ");
    mvprintw(maxY - 1, 39, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9cc5(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9301
movswl 0x4(%rdi), %ebx
jmp 0x9304
pushq $-0x2
popq %rbx
movl $0x100, %esi            # imm = 0x100
callq 0x4360
leaq 0x43a9(%rip), %rdx      # 0xd6be
pushq $0x1
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x4410
leaq 0x43b0(%rip), %rdx      # 0xd6d8
pushq $0x1b
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x4410
leaq 0x411a(%rip), %rdx      # 0xd455
pushq $0x27
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43e0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderLocation() const
void CTableController::renderLocation() const {
    move(0, HEADER_VALUES_COLUMN);
    clrtoeol();
    move(1, HEADER_VALUES_COLUMN + 2);
    clrtoeol();

    mvprintw(0, HEADER_VALUES_COLUMN, ": row    = %d", m_rowPosition);
    mvprintw(1, HEADER_VALUES_COLUMN + 2, "column = %d", m_colPosition);

    refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xb
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x4210
movq 0x9c38(%rip), %r12      # 0x12fb8
movq (%r12), %rdi
callq 0x4350
pushq $0x1
popq %r14
pushq $0xd
popq %r15
movl %r14d, %edi
movl %r15d, %esi
callq 0x4210
movq (%r12), %rdi
callq 0x4350
movl 0x78(%rbx), %ecx
leaq 0x42c4(%rip), %rdx      # 0xd673
xorl %edi, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movl 0x7c(%rbx), %ecx
leaq 0x42bd(%rip), %rdx      # 0xd681
movl %r14d, %edi
movl %r15d, %esi
xorl %eax, %eax
callq 0x4410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderValue() const
void CTableController::renderValue() const {
    move(3, HEADER_VALUES_COLUMN);
    clrtoeol();

    mvprintw(3, HEADER_VALUES_COLUMN, ": %s",
		m_database.getValue(m_rowPosition, m_colPosition).c_str());

    refresh();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x3
popq %rbp
pushq $0xb
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x4210
movq 0x9bb7(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
callq 0x4350
leaq 0x8(%rbx), %rsi
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5b2c
movq (%rbx), %rcx
leaq 0x4265(%rip), %rdx      # 0xd68d
movl %ebp, %edi
movl %r14d, %esi
xorl %eax, %eax
callq 0x4410
movq %rsp, %rdi
callq 0x4150
callq 0x4550
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderExpression() const
void CTableController::renderExpression() const {
    move(4, HEADER_VALUES_COLUMN);
    clrtoeol();

    mvprintw(4, HEADER_VALUES_COLUMN, ": %s",
		m_database.getExpression(m_rowPosition, m_colPosition).c_str());

    refresh();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x4
popq %rbp
pushq $0xb
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x4210
movq 0x9b37(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
callq 0x4350
leaq 0x8(%rbx), %rsi
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5c5e
movq (%rbx), %rcx
leaq 0x41e5(%rip), %rdx      # 0xd68d
movl %ebp, %edi
movl %r14d, %esi
xorl %eax, %eax
callq 0x4410
movq %rsp, %rdi
callq 0x4150
callq 0x4550
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CSplashscreenController.cpp
// Function: CSplashscreenController::redraw()
void CSplashscreenController::redraw() {
    clear();

    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    init_pair(2, COLOR_RED, COLOR_WHITE);
    attron(A_BOLD | COLOR_PAIR(2));
    mvprintw(0, 1, "Your terminal window is too small!");
    attroff(A_BOLD | COLOR_PAIR(2));

    mvprintw(2, 1, "Make sure it is at least 78x27.");
    mvprintw(3, 1, "Try resizing it.");


    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x4570
movq 0x99d5(%rip), %r15      # 0x12fb8
movq (%r15), %rax
testq %rax, %rax
je 0x95f1
movswl 0x4(%rax), %ebx
jmp 0x95f4
pushq $-0x2
popq %rbx
pushq $0x2
popq %r14
pushq $0x1
popq %rbp
pushq $0x7
popq %rdx
movl %r14d, %edi
movl %ebp, %esi
callq 0x4050
movq (%r15), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x4170
leaq 0x419b(%rip), %rdx      # 0xd7b9
xorl %edi, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r15), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x43e0
leaq 0x419d(%rip), %rdx      # 0xd7dc
movl %r14d, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
leaq 0x41aa(%rip), %rdx      # 0xd7fc
pushq $0x3
popq %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r15), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4360
leaq 0x3de3(%rip), %rdx      # 0xd455
movl %ebx, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r15), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CWelcomeController.cpp
// Function: CWelcomeController::redraw()
void CWelcomeController::redraw() {
    clear();

    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    init_pair(2, COLOR_RED, COLOR_WHITE);
    attron(A_BOLD | COLOR_PAIR(2));
    mvprintw(1, 1, " WELCOME TO THE ULTIMATE SPREADSHEET EDITOR! ");
    attroff(A_BOLD | COLOR_PAIR(2));

    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " F3 - go to the spreadsheet ");
    mvprintw(maxY - 1, 30, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x4570
movq 0x98f4(%rip), %r14      # 0x12fb8
movq (%r14), %rax
testq %rax, %rax
je 0x96d2
movswl 0x4(%rax), %ebx
jmp 0x96d5
pushq $-0x2
popq %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rbp
pushq $0x7
popq %rdx
movl %ebp, %esi
callq 0x4050
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x4170
leaq 0x412c(%rip), %rdx      # 0xd827
movl %ebp, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x43e0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4360
leaq 0x412c(%rip), %rdx      # 0xd855
movl %ebx, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4410
leaq 0x3d1a(%rip), %rdx      # 0xd455
pushq $0x1e
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x4410
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43e0
popq %rbx
popq %r14
popq %rbp
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpArgCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned int OpArgCount(const std::string& s) {
    unsigned int val = 1;

    if (s == "*" || s == "/" || s == "%" || s == "+" || s == "-" || s == "="
		|| s == "^" || s == "POW") {
	  val = 2;
    } else if (s == "!") {
	  val = 1;
    }

    return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x3872(%rip), %rsi      # 0xd00c
callq 0xb473
pushq $0x2
popq %rbx
testb %al, %al
jne 0x9845
leaq 0x385d(%rip), %rsi      # 0xd00e
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x383e(%rip), %rsi      # 0xd006
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x382d(%rip), %rsi      # 0xd008
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x381c(%rip), %rsi      # 0xd00a
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x3ca8(%rip), %rsi      # 0xd4a9
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x3bc1(%rip), %rsi      # 0xd3d5
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x40a9(%rip), %rsi      # 0xd8d0
movq %r14, %rdi
callq 0xb473
testb %al, %al
jne 0x9845
leaq 0x3fa0(%rip), %rsi      # 0xd7da
movq %r14, %rdi
callq 0xb473
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpPrecedence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int OpPrecedence(const std::string& s) {
    int precedence = 1;

    if (s == "!") {
	  precedence = 4;
    } else if (s == "*" || s == "/" || s == "%") {
	  precedence = 3;
    } else if (s == "+" || s == "-") {
	  precedence = 2;
    } else if (s == "=") {
	  precedence = 1;
    }

    return precedence;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f7e(%rip), %rsi      # 0xd7da
callq 0xb473
testb %al, %al
je 0x986a
pushq $0x4
popq %rbp
jmp 0x98cf
leaq 0x379b(%rip), %rsi      # 0xd00c
movq %rbx, %rdi
callq 0xb473
pushq $0x3
popq %rbp
testb %al, %al
jne 0x98cf
leaq 0x3787(%rip), %rsi      # 0xd00e
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x98cf
leaq 0x376c(%rip), %rsi      # 0xd006
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x98cf
leaq 0x375b(%rip), %rsi      # 0xd008
movq %rbx, %rdi
callq 0xb473
pushq $0x2
popq %rbp
testb %al, %al
jne 0x98cf
leaq 0x3747(%rip), %rsi      # 0xd00a
movq %rbx, %rdi
callq 0xb473
testb %al, %al
je 0x98d8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3bca(%rip), %rsi      # 0xd4a9
movq %rbx, %rdi
callq 0xb473
pushq $0x1
jmp 0x9867
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpLeftAssoc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool OpLeftAssoc(const std::string& s) {
    // left to right
    if (s == "*" || s == "/" || s == "%" || s == "+" || s == "-") {
	  return true;
    }// right to left
    else if (s == "=" || s == "!") {
	  return false;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3711(%rip), %rsi      # 0xd00c
callq 0xb473
movb $0x1, %bpl
testb %al, %al
jne 0x9977
leaq 0x3700(%rip), %rsi      # 0xd00e
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x9977
leaq 0x36e5(%rip), %rsi      # 0xd006
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x9977
leaq 0x36d4(%rip), %rsi      # 0xd008
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x9977
leaq 0x36c3(%rip), %rsi      # 0xd00a
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x9977
leaq 0x3b4f(%rip), %rsi      # 0xd4a9
movq %rbx, %rdi
callq 0xb473
testb %al, %al
jne 0x9975
leaq 0x3e6d(%rip), %rsi      # 0xd7da
movq %rbx, %rdi
callq 0xb473
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsFunction(const std::string& s) {
    std::string str = UpperCase(s);

    if (str.find("^") != std::string::npos
		|| str.find("SIN") != std::string::npos
		|| str.find("COS") != std::string::npos
		|| str.find("TAN") != std::string::npos
		|| str.find("LN") != std::string::npos
		|| str.find("LOG") != std::string::npos
		|| str.find("EXP") != std::string::npos
		|| str.find("POW") != std::string::npos
		|| str.find("SQRT") != std::string::npos) {
	  return true;
    }

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4440
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a13
movq %rbx, %rdi
callq 0x4150
leaq 0x38a6(%rip), %rsi      # 0xd3d5
movq %r14, %rdi
xorl %edx, %edx
callq 0x4640
movb $0x1, %bl
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d8d(%rip), %rsi      # 0xd8d9
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d74(%rip), %rsi      # 0xd8dd
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d5b(%rip), %rsi      # 0xd8e1
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d46(%rip), %rsi      # 0xd8e5
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d30(%rip), %rsi      # 0xd8e8
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3d1b(%rip), %rsi      # 0xd8ec
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3ce6(%rip), %rsi      # 0xd8d0
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
jne 0x9c16
leaq 0x3ced(%rip), %rsi      # 0xd8f0
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x4640
cmpq $-0x1, %rax
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x4150
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsFloat(const std::string& s) {
    std::istringstream iss(s);
    float f;
    iss >> std::noskipws >> f;
    return iss.eof() && !iss.fail();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4540
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x28(%rsp,%rax) # imm = 0xFFFFEFFF
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4660
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
sete %bl
callq 0x4160
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsNumber(const std::string& s) {
    std::string::const_iterator it = s.begin();
    while (it != s.end() && std::isdigit(*it, std::locale())) {
	  ++it;
    }

    return !s.empty() && it == s.end();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rsp, %r14
movq %rax, %r15
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx), %rdx
cmpq %rdx, %r15
je 0x9cf0
movsbl (%r15), %ebp
movq %r14, %rdi
callq 0x4670
movl %ebp, %edi
movq %r14, %rsi
callq 0xb480
movl %eax, %ebp
movq %r14, %rdi
callq 0x4450
movq (%rbx), %rax
testb %bpl, %bpl
je 0x9cec
incq %r15
jmp 0x9cb2
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rcx, %rax
cmpq %rax, %r15
sete %al
andb %dl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4450
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: CExpressionParser::MatchingParetheses()
bool CExpressionParser::MatchingParetheses() {
    std::vector<std::string> inputs;

    // Check left and right parentheses are equal
    const size_t nLeft = std::count(m_strInput.begin(), m_strInput.end(), '(');
    const size_t nRight = std::count(m_strInput.begin(), m_strInput.end(), ')');

    return nLeft == nRight && !m_strInput.empty();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
leaq 0xf(%rsp), %rdx
movb $0x28, (%rdx)
callq 0xb80d
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
leaq 0xf(%rsp), %rdx
movb $0x29, (%rdx)
callq 0xb80d
cmpq %rax, %r14
sete %al
cmpq $0x0, 0x8(%rbx)
setne %bl
andb %al, %bl
leaq 0x10(%rsp), %rdi
callq 0x7b9a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x9dc7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7b9a
movq %rbx, %rdi
callq 0x4590